Refactor NodeDefinition -> Concept (deprecating old names but keeping them)

Author: alessiostalla

CHANGELOG.md

@@ -2,12 +2,17 @@
 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/).
 
-## [Unreleased]
+## [1.6.31] [Unreleased]
+
+### Added
+- Concept (was _NodeDefinition_) has a reference to the extended concept.
 
 ### Changed
 - `Position`'s method `isEmpty` is deprecated in favour of `isFlat` to ensure consistency across the [StarLasu](https://github.com/Strumenta/StarLasu) libraries collection.
-- `Issue`'s messages are capitalized.
+- `Issue`'s messages are capitalized, as in recent versions of Kolasu.
 - Parsing `Issue`s' position uses the token's length.
+- Start renaming `NodeDefinition` to `Concept` but retain the old names as deprecated types/functions/methods.
+- Update Lionweb to version `0.6.12`.
 
 ## [1.6.30] – 2024-09-30
 

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

src/interop/ecore.ts

@@ -5,13 +5,13 @@
 import {
     ensureNodeDefinition,
     ensurePackage,
-    getNodeDefinition,
+    getConcept,
     Node,
-    NODE_TYPES, NodeDefinition,
+    NODE_TYPES,
     PackageDescription,
     Feature,
     registerNodeDefinition,
-    registerNodeAttribute
+    registerNodeAttribute, Concept
 } from "../model/model";
 import ECore from "ecore/dist/ecore";
 import {Point, Position} from "../model/position";
@@ -101,15 +101,15 @@ function registerEClass(nodeType: string, packageDef: PackageDescription, ePacka
     });
     constructor[ECLASS_SYMBOL] = eClass;
     const proto = Object.getPrototypeOf(constructor);
-    const parentNodeDef = getNodeDefinition(proto);
+    const parentNodeDef = getConcept(proto);
     if(parentNodeDef && parentNodeDef.package && parentNodeDef.name) {
         const {packageDef, ePackage} = registerEPackage(parentNodeDef.package, {});
         const superclass = registerEClass(parentNodeDef.name, packageDef, ePackage);
         eClass.get("eSuperTypes").add(superclass);
     } else {
         eClass.get("eSuperTypes").add(THE_NODE_ECLASS);
     }
-    const nodeDef = getNodeDefinition(constructor);
+    const nodeDef = getConcept(constructor);
     if (nodeDef) {
         for (const prop in nodeDef.features) {
             const property = nodeDef.features[prop];
@@ -841,17 +841,17 @@ export class ECoreNode extends NodeAdapter implements PossiblyNamed {
         return this.getAttributeValue("name");
     }
 
-    private _nodeDefinition?: NodeDefinition;
+    private _concept?: Concept;
 
-    get nodeDefinition() {
-        if (!this._nodeDefinition) {
-            this._nodeDefinition = {
+    get concept() {
+        if (!this._concept) {
+            this._concept = {
                 package: this.eo.eClass.eContainer.get("name") as string,
                 name: this.eo.eClass.get("name") as string,
                 features: this.getFeatures()
             };
         }
-        return this._nodeDefinition;
+        return this._concept;
     }
 
     get(...path: string[]): NodeAdapter | undefined {

src/interop/lionweb.ts

@@ -4,7 +4,7 @@
  */
 import {
     Classifier,
-    Concept,
+    Concept as LWConcept,
     Containment, Datatype, DefaultPrimitiveTypeDeserializer, deserializeSerializationChunk,
     Feature as LWFeature,
     Id,
@@ -19,17 +19,17 @@ import {
     NodeAdapter,
     Issue,
     Node,
-    NodeDefinition,
+    Concept,
     Position,
     Feature,
     Point,
     TraceNode,
-    getNodeDefinition
+    getConcept
 } from "..";
 import {STARLASU_LANGUAGE} from "./lionweb-starlasu-language";
 export {STARLASU_LANGUAGE} from "./lionweb-starlasu-language";
 
-export const ASTNode = STARLASU_LANGUAGE.entities.find(e => e.name == "ASTNode")! as Concept;
+export const ASTNode = STARLASU_LANGUAGE.entities.find(e => e.name == "ASTNode")! as LWConcept;
 export const PositionFeature = ASTNode.features.find(f => f.name == "position")! as Property;
 export const PositionType = PositionFeature.type!;
 export const PointType = STARLASU_LANGUAGE.entities.find(e => e.name == "Point")! as Datatype;
@@ -55,7 +55,7 @@ export class LanguageMapping {
 
     register(nodeType: any, classifier: Classifier) {
         if (!classifier) {
-            throw new Error(`Can't register ${getNodeDefinition(nodeType)?.name}: not a classifier: ${classifier}`);
+            throw new Error(`Can't register ${getConcept(nodeType)?.name}: not a classifier: ${classifier}`);
         }
         this.nodeTypes.set(nodeType, classifier);
         this.classifiers.set(classifier, nodeType);
@@ -83,7 +83,7 @@ function importFeature(feature: LWFeature): Feature | undefined {
     return def;
 }
 
-function importConcept(concept: NodeDefinition | undefined, classifier: Classifier) {
+function importConcept(concept: Concept | undefined, classifier: Classifier) {
     concept = {
         name: classifier.name,
         features: {},
@@ -100,7 +100,7 @@ function importConcept(concept: NodeDefinition | undefined, classifier: Classifi
 
 export class TylasuInstantiationFacade implements InstantiationFacade<TylasuWrapper> {
 
-    protected readonly concepts = new Map<Classifier, NodeDefinition>();
+    protected readonly concepts = new Map<Classifier, Concept>();
 
     constructor(public languageMappings: LanguageMapping[] = [STARLASU_LANGUAGE_MAPPING]) {}
 
@@ -166,7 +166,7 @@ STARLASU_LANGUAGE_MAPPING.register(Node, AST_NODE_CLASSIFIER);
 
 function allFeatures(classifier: Classifier) {
     const features = [...classifier.features];
-    if (classifier instanceof Concept) {
+    if (classifier instanceof LWConcept) {
         const superConcept = classifier.extends;
         if (superConcept) {
             features.push(...allFeatures(superConcept));
@@ -187,12 +187,12 @@ export class LionwebNode extends NodeAdapter {
 
     parent: LionwebNode;
 
-    get nodeDefinition() {
-        return this._nodeDefinition;
+    get concept() {
+        return this._concept;
     }
 
     constructor(
-        protected readonly _nodeDefinition: NodeDefinition,
+        protected readonly _concept: Concept,
         protected readonly classifier: Classifier,
         protected lwnode: LWNodeInterface
     ) {
@@ -216,8 +216,8 @@ export class LionwebNode extends NodeAdapter {
 
     getAttributes(): { [p: string]: any } {
         const attributes = {};
-        for (const p in this.nodeDefinition.features) {
-            if (!this.nodeDefinition.features[p].child) {
+        for (const p in this.concept.features) {
+            if (!this.concept.features[p].child) {
                 attributes[p] = this.getAttributeValue(p);
             }
         }
@@ -252,15 +252,15 @@ export class LionwebNode extends NodeAdapter {
     }
 
     isOfKnownType(name: string): boolean {
-        return this.classifier instanceof Concept && conceptImplements(this.classifier, name);
+        return this.classifier instanceof LWConcept && conceptImplements(this.classifier, name);
     }
 
     equals(other: NodeAdapter | undefined): boolean {
         return other instanceof LionwebNode && other.lwnode == this.lwnode;
     }
 }
 
-function conceptImplements(concept: Concept, interfaceName: string) {
+function conceptImplements(concept: LWConcept, interfaceName: string) {
     const directlyImplements = !!concept.implements.find(intf => intf.name == interfaceName);
     return directlyImplements || !!(concept.extends && conceptImplements(concept.extends, interfaceName));
 }

src/model/model.ts

@@ -2,7 +2,7 @@ import {Position, Source} from "./position";
 import "reflect-metadata";
 import {PossiblyNamed, ReferenceByName} from "./naming";
 
-export const NODE_DEFINITION_SYMBOL = Symbol("nodeDefinition");
+export const CONCEPT_SYMBOL = Symbol("concept");
 
 export type PackageDescription = {
     name: string,
@@ -12,14 +12,19 @@ export const NODE_TYPES: { [name: string]: PackageDescription } = {
     "": { name: "", nodes: {} }
 };
 
-export type NodeDefinition = {
+export type Concept = {
     package?: string,
     name?: string,
     features: { [name: string | symbol]: Feature },
     resolved?: boolean;
-    inheritsFrom?: NodeDefinition
+    inheritsFrom?: Concept
 };
 
+/**
+ * @deprecated use Concept instead.
+ */
+export type NodeDefinition = Concept;
+
 export type Feature = {
     name: string | symbol,
     child?: boolean,
@@ -35,45 +40,52 @@ export type Feature = {
  */
 export type PropertyDefinition = Feature;
 
+/**
+ * @deprecated in favor of getConcept
+ */
 export function getNodeDefinition(node: Node | (abstract new (...args: any[]) => Node)): NodeDefinition {
+    return getConcept(node);
+}
+
+export function getConcept(node: Node | (abstract new (...args: any[]) => Node)): Concept {
     const target = typeof node === "function" ? node : node.constructor;
-    let definition: NodeDefinition;
-    if(Object.prototype.hasOwnProperty.call(target, NODE_DEFINITION_SYMBOL)) {
-        definition = target[NODE_DEFINITION_SYMBOL] as NodeDefinition;
+    let concept: Concept;
+    if(Object.prototype.hasOwnProperty.call(target, CONCEPT_SYMBOL)) {
+        concept = target[CONCEPT_SYMBOL] as Concept;
     } else {
-        const inheritedFeatures = {...(target[NODE_DEFINITION_SYMBOL]?.features || {})};
+        const inheritedFeatures = {...(target[CONCEPT_SYMBOL]?.features || {})};
         for (const p in inheritedFeatures) {
             inheritedFeatures[p] = { inherited: true, ...inheritedFeatures[p] };
         }
-        target[NODE_DEFINITION_SYMBOL] = definition = {
+        target[CONCEPT_SYMBOL] = concept = {
             features: inheritedFeatures,
             resolved: false
         };
     }
-    if(definition && definition.features && !definition.resolved) {
+    if(concept && concept.features && !concept.resolved) {
         try {
             let metadataHolder;
             try {
                 metadataHolder = new (node as any)();
             } catch {
                 metadataHolder = node;
             }
-            for(const p in definition.features) {
-                if (!definition.features[p].type) {
+            for(const p in concept.features) {
+                if (!concept.features[p].type) {
                     const type = Reflect.getMetadata("design:type", metadataHolder, p);
-                    definition.features[p].type = type;
+                    concept.features[p].type = type;
                     if(type === Array) {
-                        definition.features[p].arrayType =
+                        concept.features[p].arrayType =
                             Reflect.getMetadata("design:arrayElementType", metadataHolder, p);
                     }
                 }
             }
-            definition.resolved = true;
+            concept.resolved = true;
         } catch {
             //Ignore
         }
     }
-    return definition;
+    return concept;
 }
 
 export abstract class Origin {
@@ -166,8 +178,13 @@ export abstract class Node extends Origin implements Destination {
         return Object.getOwnPropertyNames(props).filter(p => props[p].child);
     }
 
+    get concept(): Concept {
+        return getConcept(this);
+    }
+
+    /** @deprecated use concept */
     get nodeDefinition(): NodeDefinition {
-        return getNodeDefinition(this);
+        return this.concept;
     }
 
     get features(): FeatureDescription[] {
@@ -461,8 +478,8 @@ export function setNodeRedefinitionStrategy(strategy: typeof errorOnRedefinition
 }
 
 export function registerNodeDefinition<T extends Node>(
-    target: abstract new (...args: any[]) => T, pkg?: string, name?: string): NodeDefinition {
-    let def: NodeDefinition;
+    target: abstract new (...args: any[]) => T, pkg?: string, name?: string): Concept {
+    let def: Concept;
     if(pkg !== undefined) {
         if (!name) {
             throw new Error("Package name without node name");
@@ -473,8 +490,8 @@ export function registerNodeDefinition<T extends Node>(
             nodeRedefinitionStrategy(name, target, existingTarget);
         }
     }
-    const existingDef = target[NODE_DEFINITION_SYMBOL] as NodeDefinition;
-    if(Object.prototype.hasOwnProperty.call(target, NODE_DEFINITION_SYMBOL)) {
+    const existingDef = target[CONCEPT_SYMBOL] as Concept;
+    if(Object.prototype.hasOwnProperty.call(target, CONCEPT_SYMBOL)) {
         if((existingDef.package !== undefined && existingDef.package != pkg) ||
             (existingDef.name !== undefined && existingDef.name != name)) {
             throw new Error(`Type ${pkg}.${name} (${target}) is already defined as ${JSON.stringify(existingDef)}`);
@@ -499,22 +516,27 @@ export function registerNodeDefinition<T extends Node>(
     if(pkg !== undefined && name !== undefined) {
         NODE_TYPES[pkg].nodes[name] = target;
     }
-    target[NODE_DEFINITION_SYMBOL] = def;
+    target[CONCEPT_SYMBOL] = def;
     return def;
 }
 
-export function ensureNodeDefinition(node: Node | { new (...args: any[]): Node }): NodeDefinition {
-    let definition = getNodeDefinition(node);
-    if (!definition) {
+export function ensureConcept(node: Node | { new (...args: any[]): Node }): Concept {
+    let concept = getConcept(node);
+    if (!concept) {
         if(typeof node === 'function') {
-            definition = registerNodeDefinition(node);
+            concept = registerNodeDefinition(node);
         } else if(typeof node.constructor === 'function') {
-            definition = registerNodeDefinition(node.constructor as any);
+            concept = registerNodeDefinition(node.constructor as any);
         } else {
             throw new Error("Not a valid node: " + node);
         }
     }
-    return definition;
+    return concept;
+}
+
+/** @deprecated use ensureConcept */
+export function ensureNodeDefinition(node: Node | { new (...args: any[]): Node }): Concept {
+    return ensureConcept(node);
 }
 
 export function registerNodeAttribute<T extends Node>(
@@ -523,7 +545,7 @@ export function registerNodeAttribute<T extends Node>(
     if (methodName == "parent" || methodName == "children" || methodName == "origin") {
         methodName = Symbol(methodName);
     }
-    const definition = ensureNodeDefinition(type);
+    const definition = ensureConcept(type);
     if (!definition.features[methodName]) {
         definition.features[methodName] = {
             name: methodName