Fix: ignore non-Node containments in Lionweb trees (e.g. Position)

Author: alessiostalla

src/interop/ecore.ts

@@ -9,7 +9,7 @@ import {
     Node,
     NODE_TYPES, NodeDefinition,
     PackageDescription,
-    PropertyDefinition,
+    Feature,
     registerNodeDefinition,
     registerNodeAttribute
 } from "../model/model";
@@ -946,8 +946,8 @@ export class ECoreNode extends NodeAdapter implements PossiblyNamed {
         return this.eo.eContainingFeature?.get("name");
     }
 
-    getFeatures(): { [name: string | symbol]: PropertyDefinition } {
-        const result: { [name: string | symbol]: PropertyDefinition } = {};
+    getFeatures(): { [name: string | symbol]: Feature } {
+        const result: { [name: string | symbol]: Feature } = {};
         const eClass = this.eo.eClass;
         const features = eClass.get("eAllStructuralFeatures");
         for (const ft of features) {

src/interop/lionweb.ts

@@ -6,22 +6,24 @@ import {
     Classifier,
     Concept,
     Containment,
-    Feature,
+    Feature as LWFeature,
     Id,
     InstantiationFacade,
     Interface,
     Language,
-    Node as LionwebNodeInterface
+    Node as LWNodeInterface
 } from "@lionweb/core";
-import {NodeAdapter, Issue, Node, NodeDefinition, Position, PropertyDefinition} from "..";
+import {NodeAdapter, Issue, Node, NodeDefinition, Position, Feature} from "..";
 import {STARLASU_LANGUAGE} from "./lionweb-starlasu-language";
 export {STARLASU_LANGUAGE} from "./lionweb-starlasu-language";
 
-export class TylasuNodeWrapper implements LionwebNodeInterface {
+export const ASTNode = STARLASU_LANGUAGE.entities.find(e => e.name == "ASTNode")!;
+
+export class TylasuNodeWrapper implements LWNodeInterface {
     id: Id;
     node: Node;
-    parent?: LionwebNodeInterface;
-    annotations: LionwebNodeInterface[];
+    parent?: LWNodeInterface;
+    annotations: LWNodeInterface[];
 }
 
 export class LanguageMapping {
@@ -43,11 +45,23 @@ export class LanguageMapping {
     }
 }
 
-function featureToProperty(feature: Feature): PropertyDefinition {
-    const def: PropertyDefinition = { name: feature.name };
+function isASTNode(classifier: Classifier) {
+    return (classifier instanceof Concept) &&
+        (classifier.key == ASTNode.key || (classifier.extends && isASTNode(classifier.extends)));
+}
+
+function importFeature(feature: LWFeature): Feature | undefined {
+    const def: Feature = { name: feature.name };
     if (feature instanceof Containment) {
-        def.child = true;
-        def.multiple = feature.multiple;
+        if (isASTNode(feature.classifier)) {
+            def.child = true;
+            def.multiple = feature.multiple;
+        } else {
+            // TODO we assume that:
+            //  1) we're importing a StarLasu AST
+            //  2) containments in a StarLasu AST are either AST nodes or internal StarLasu objects like the position
+            return undefined;
+        }
     }
     return def
 }
@@ -81,7 +95,7 @@ export class TylasuInstantiationFacade implements InstantiationFacade<TylasuNode
             annotations: []
         };
     }
-    setFeatureValue(node: TylasuNodeWrapper, feature: Feature, value: unknown): void {
+    setFeatureValue(node: TylasuNodeWrapper, feature: LWFeature, value: unknown): void {
         if (feature instanceof Containment) {
             if (feature.multiple) {
                 node.node.addChild(feature.name, (value as TylasuNodeWrapper)?.node);
@@ -132,16 +146,19 @@ export class LionwebNode extends NodeAdapter {
 
     constructor(
         public readonly classifier: Classifier,
-        protected lwnode: LionwebNodeInterface
+        protected lwnode: LWNodeInterface
     ) {
         super();
-        const properties = {};
+        const features = {};
         allFeatures(classifier).forEach(f => {
-            properties[f.name] = featureToProperty(f);
+            const feature = importFeature(f);
+            if (feature) {
+                features[f.name] = feature;
+            }
         });
         this._nodeDefinition = {
             name: classifier.name,
-            features: properties,
+            features,
             resolved: true
         };
     }

src/model/model.ts

@@ -15,11 +15,11 @@ export const NODE_TYPES: { [name: string]: PackageDescription } = {
 export type NodeDefinition = {
     package?: string,
     name?: string,
-    features: { [name: string | symbol]: PropertyDefinition },
+    features: { [name: string | symbol]: Feature },
     resolved?: boolean;
 };
 
-export type PropertyDefinition = {
+export type Feature = {
     name: string | symbol,
     child?: boolean,
     multiple?: boolean,
@@ -29,6 +29,11 @@ export type PropertyDefinition = {
     arrayType?: any
 }
 
+/**
+ * @deprecated replaced by Feature
+ */
+export type PropertyDefinition = Feature;
+
 export function getNodeDefinition(node: Node | (abstract new (...args: any[]) => Node)): NodeDefinition {
     const target = typeof node === "function" ? node : node.constructor;
     let definition: NodeDefinition;
@@ -174,7 +179,7 @@ export abstract class Node extends Origin implements Destination {
         });
     }
 
-    containment(name: string | symbol): PropertyDefinition | undefined {
+    containment(name: string | symbol): Feature | undefined {
         const props = this.nodeDefinition?.features || {};
         return props[name]?.child ? props[name] : undefined;
     }
@@ -457,7 +462,7 @@ export function ensureNodeDefinition(node: Node | { new (...args: any[]): Node }
 
 export function registerNodeAttribute<T extends Node>(
     type: { new(...args: any[]): T }, methodName: string | symbol
-): PropertyDefinition {
+): Feature {
     if (methodName == "parent" || methodName == "children" || methodName == "origin") {
         methodName = Symbol(methodName);
     }
@@ -471,15 +476,15 @@ export function registerNodeAttribute<T extends Node>(
 }
 
 export function registerNodeChild<T extends Node>(
-    type: new (...args: any[]) => T, methodName: string, multiple: boolean = false): PropertyDefinition {
+    type: new (...args: any[]) => T, methodName: string, multiple: boolean = false): Feature {
     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 {
+    type: new (...args: any[]) => T, methodName: string): Feature {
     const propInfo = registerNodeAttribute(type, methodName);
     propInfo.reference = true;
     return propInfo;