#15 and #16: improve Ecore support and support of transpilation traces.

Author: alessiostalla

pylasu/StrumentaLanguageSupport/__init__.py

@@ -25,6 +25,7 @@
 ASTNode.destination.eType = Destination
 Issue.position.eType = Position
 #  TODO eGenericType not supported ReferenceByName.referenced.eType =
+ReferenceByName.referenced.eType = ASTNode
 #  TODO eGenericType not supported
 Result.root.eType = ASTNode
 Result.issues.eType = Issue

pylasu/emf/metamodel_builder.py

@@ -3,9 +3,9 @@
 from enum import Enum, EnumMeta
 from types import resolve_bases
 
-from pyecore.ecore import EAttribute, ECollection, EObject, EPackage, EReference, MetaEClass, EBoolean, EString, EInt, EEnum
+from pyecore.ecore import EAttribute, ECollection, EObject, EPackage, EReference, MetaEClass, EBoolean, EString, EInt, \
+    EEnum
 from pyecore.resources import Resource
-
 from pylasu import StrumentaLanguageSupport as starlasu
 from pylasu.StrumentaLanguageSupport import ASTNode
 from pylasu.emf.model import find_eclassifier
@@ -14,7 +14,8 @@
 
 
 class MetamodelBuilder:
-    def __init__(self, package_name: str, ns_uri: str, ns_prefix: str = None, resource: Resource = None):
+    def __init__(self, package_name: str, ns_uri: str, ns_prefix: str = None, resource: Resource = None,
+                 base_node_class: type = Node):
         self.package = EPackage(package_name, ns_uri, ns_prefix)
         if resource:
             resource.append(self.package)
@@ -23,13 +24,14 @@ def __init__(self, package_name: str, ns_uri: str, ns_prefix: str = None, resour
             int: EInt,
             str: EString,
         }
+        self.base_node_class = base_node_class
         self.forward_references = []
 
     def can_provide_class(self, cls: type):
         return cls.__module__ == self.package.name
 
     def provide_class(self, cls: type):
-        if cls == Node:
+        if cls == self.base_node_class:
             return ASTNode
         if not self.can_provide_class(cls):
             if self.package.eResource:
@@ -44,15 +46,17 @@ def provide_class(self, cls: type):
                 "position": EReference("position", starlasu.Position, containment=True)
             }
             for attr in anns if anns else []:
-                if is_dataclass(cls):
+                if attr.startswith('_'):
+                    continue
+                elif is_dataclass(cls):
                     field = next((f for f in fields(cls) if f.name == attr), None)
                     if isinstance(field, InternalField):
                         continue
                 attr_type = anns[attr]
                 nmspc[attr] = self.to_structural_feature(attr, attr_type)
             bases = []
             for c in cls.__mro__[1:]:
-                if c == Node:
+                if c == self.base_node_class:
                     bases.append(ASTNode)
                 elif self.can_provide_class(c):
                     bases.append(self.provide_class(c))
@@ -69,7 +73,15 @@ def provide_class(self, cls: type):
             self.forward_references = [(t, r) for t, r in self.forward_references if not r.eType]
         return eclass
 
-    def to_structural_feature(self, attr, attr_type):
+    def to_structural_feature(self, attr, attr_type, unsupported_type_handler=None):
+        def raise_on_unsupported_type(attr_type, attr):
+            raise Exception("Unsupported type " + str(attr_type) + " for attribute " + attr)
+
+        def default_unsupported_type(_, __):
+            return EObject
+
+        if not unsupported_type_handler:
+            unsupported_type_handler = raise_on_unsupported_type
         if isinstance(attr_type, str):
             resolved = self.package.getEClassifier(attr_type)
             if resolved:
@@ -82,21 +94,24 @@ def to_structural_feature(self, attr, attr_type):
             return EAttribute(attr, self.data_types[attr_type])
         elif attr_type == object:
             return EAttribute(attr)
-        elif isinstance(attr_type, type) and issubclass(attr_type, Node):
+        elif isinstance(attr_type, type) and issubclass(attr_type, self.base_node_class):
             return EReference(attr, self.provide_class(attr_type), containment=True)
-        elif typing.get_origin(attr_type) == list:
+        elif isinstance(typing.get_origin(attr_type), type) and \
+                issubclass(typing.get_origin(attr_type), typing.Sequence):
             type_args = typing.get_args(attr_type)
             if type_args and len(type_args) == 1:
-                ft = self.to_structural_feature(attr, type_args[0])
+                ft = self.to_structural_feature(attr, type_args[0], default_unsupported_type)
                 ft.upperBound = -1
                 return ft
+        elif typing.get_origin(attr_type) == typing.Union:
+            return EReference(attr, EObject, containment=True)  # TODO here we could refine the type better
         elif isinstance(attr_type, EnumMeta) and issubclass(attr_type, Enum):
             tp = EEnum(name=attr_type.__name__, literals=attr_type.__members__)
             tp.ePackage = self.package
             self.data_types[attr_type] = tp
             return EAttribute(attr, tp)
         else:
-            raise Exception("Unsupported type " + str(attr_type) + " for attribute " + attr)
+            return unsupported_type_handler(attr_type, attr)
 
     def generate(self):
         if self.forward_references:

pylasu/emf/model.py

@@ -34,7 +34,7 @@ def to_eobject(self: Node, resource: Resource, mappings=None):
     if mappings is None:
         mappings = {}
     elif id(self) in mappings:
-        return mappings[self]
+        return mappings[id(self)]
     eclass = resource.find_eclassifier(type(self))
     if not eclass:
         raise Exception("Unknown classifier for " + str(type(self)))

pylasu/playground/__init__.py

@@ -1,2 +1,2 @@
 from .transpilation_trace import TranspilationTrace
-from .transpilation_trace_ecore import TranspilationTrace as ETranspilationTrace
+from .transpilation_trace_ecore import JsonResource, TranspilationTrace as ETranspilationTrace

pylasu/playground/transpilation_trace.py

@@ -5,7 +5,6 @@
 from pyecore.resources import Resource, ResourceSet, URI
 
 from pylasu import StrumentaLanguageSupport as starlasu
-from pylasu.emf.model import to_eobject
 from pylasu.playground.transpilation_trace_ecore import TranspilationTrace as ETranspilationTrace, JsonResource
 from pylasu.validation.validation import Result, Issue
 
@@ -22,8 +21,8 @@ def to_eobject(self, resource: Resource):
         mappings = {}
         return ETranspilationTrace(
             original_code=self.original_code,
-            source_result=starlasu.Result(root=to_eobject(self.source_result.root, resource, mappings)),
-            target_result=starlasu.Result(root=to_eobject(self.target_result.root, resource, mappings)),
+            source_result=starlasu.Result(root=self.source_result.root.to_eobject(resource, mappings)),
+            target_result=starlasu.Result(root=self.target_result.root.to_eobject(resource, mappings)),
             generated_code=self.generated_code
         )
 

pylasu/playground/transpilation_trace_ecore.py

@@ -1,6 +1,7 @@
 from io import IOBase, BytesIO
 
-from pyecore.ecore import EObject, MetaEClass, EAttribute, EString, EReference
+import pyecore.ecore
+from pyecore.ecore import EObject, MetaEClass, EAttribute, EString, EReference, EDataType
 from pyecore.resources import ResourceSet, URI
 
 from pyecore.resources.json import JsonResource as BaseJsonResource
@@ -19,6 +20,13 @@ def open_out_stream(self, other=None):
         else:
             return super().open_out_stream(other)
 
+    @staticmethod
+    def serialize_eclass(eclass):
+        if eclass.name == "EEnum" and issubclass(eclass, EDataType):
+            return f'{pyecore.ecore.nsURI}#//EEnum'
+        else:
+            return f'{eclass.eRoot().nsURI}{eclass.eURIFragment()}'
+
 
 class TranspilationTrace(EObject, metaclass=MetaEClass):
     # Note: we use camelCase here because Pyecore's JSON serialization doesn't handle having different names for