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

alessiostalla · alessiostalla · commit ef9817168f7f · 2022-09-15T18:44:19.000+02:00
diff --git a/pylasu/emf/__init__.py b/pylasu/emf/__init__.py
@@ -1,2 +1,2 @@
-from .metamodel_builder import MetamodelBuilder
 from .model import *
+from .metamodel_builder import MetamodelBuilder
diff --git a/pylasu/emf/metamodel_builder.py b/pylasu/emf/metamodel_builder.py
@@ -1,46 +1,107 @@
-from pyecore.ecore import EAttribute, EObject, EPackage, EReference, MetaEClass, EString, EInt
+import typing
+from dataclasses import is_dataclass, fields
+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.resources import Resource
 
 from pylasu import StrumentaLanguageSupport as starlasu
 from pylasu.StrumentaLanguageSupport import ASTNode
+from pylasu.emf.model import find_eclassifier
 from pylasu.model import Node
+from pylasu.model.model import InternalField
 
 
 class MetamodelBuilder:
     def __init__(self, package_name: str, ns_uri: str, ns_prefix: str = None, resource: Resource = None):
         self.package = EPackage(package_name, ns_uri, ns_prefix)
         if resource:
             resource.append(self.package)
+        self.data_types = {
+            bool: EBoolean,
+            int: EInt,
+            str: EString,
+        }
+        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:
+            return ASTNode
         if not self.can_provide_class(cls):
+            if self.package.eResource:
+                eclass = find_eclassifier(self.package.eResource, cls)
+                if eclass:
+                    return eclass
             raise Exception(self.package.name + " cannot provide class " + str(cls))
         eclass = self.package.getEClassifier(cls.__name__)
         if not eclass:
             anns = getannotations(cls)
             nmspc = {
                 "position": EReference("position", starlasu.Position, containment=True)
             }
-            for attr in anns:
-                if anns[attr] == str:
-                    nmspc[attr] = EAttribute(attr, EString)
-                elif anns[attr] == int:
-                    nmspc[attr] = EAttribute(attr, EInt)
+            for attr in anns if anns else []:
+                if 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:
                     bases.append(ASTNode)
                 elif self.can_provide_class(c):
                     bases.append(self.provide_class(c))
+                elif self.package.eResource:
+                    esuperclass = find_eclassifier(self.package.eResource, c)
+                    if esuperclass:
+                        bases.append(esuperclass)
             bases.append(EObject)
-            eclass = MetaEClass(cls.__name__, tuple(bases), nmspc)
+            eclass = MetaEClass(cls.__name__, resolve_bases(tuple(bases)), nmspc)
             eclass.eClass.ePackage = self.package
+            for (type_name, ref) in self.forward_references:
+                if type_name == cls.__name__:
+                    ref.eType = eclass
+            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):
+        if isinstance(attr_type, str):
+            resolved = self.package.getEClassifier(attr_type)
+            if resolved:
+                return EReference(attr, resolved, containment=True)
+            else:
+                forward_reference = EReference(attr, containment=True)
+                self.forward_references.append((attr_type, forward_reference))
+                return forward_reference
+        elif attr_type in self.data_types:
+            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):
+            return EReference(attr, self.provide_class(attr_type), containment=True)
+        elif typing.get_origin(attr_type) == list:
+            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.upperBound = -1
+                return ft
+        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)
+
     def generate(self):
+        if self.forward_references:
+            raise Exception("The following classes are missing from " + self.package.name + ": " +
+                            ", ".join(n for n, _ in self.forward_references))
         return self.package
 
 
@@ -53,3 +114,15 @@ def getannotations(cls):
             return cls.__dict__.get('__annotations__', None)
         else:
             return getattr(cls, '__annotations__', None)
+
+
+# Monkey patch until fix
+update_opposite = ECollection._update_opposite
+
+
+def update_opposite_if_not_none(self, owner, new_value, remove=False):
+    if owner:
+        update_opposite(self, owner, new_value, remove)
+
+
+ECollection._update_opposite = update_opposite_if_not_none
diff --git a/pylasu/emf/model.py b/pylasu/emf/model.py
@@ -1,36 +1,64 @@
+from enum import Enum
+
 from pyecore.ecore import EPackage
 from pyecore.resources import Resource
 
 from pylasu.model import Node
 from pylasu.support import extension_method
 
 
-def find_eclass_in_resource(cls: type, resource: Resource):
+def find_eclassifier_in_resource(cls: type, resource: Resource):
     pkg_name = cls.__module__
     for p in resource.contents:
         if isinstance(p, EPackage) and p.name == pkg_name:
             return p.getEClassifier(cls.__name__)
 
 
 @extension_method(Resource)
-def find_eclass(self: Resource, cls: type):
-    eclass = find_eclass_in_resource(cls, self)
+def find_eclassifier(self: Resource, cls: type):
+    eclass = find_eclassifier_in_resource(cls, self)
     if not eclass:
         for uri in (self.resource_set.resources if self.resource_set else {}):
             resource = self.resource_set.resources[uri]
             if resource != self:
-                eclass = find_eclass_in_resource(cls, resource)
+                eclass = find_eclassifier_in_resource(cls, resource)
                 if eclass:
                     return eclass
     return eclass
 
 
 @extension_method(Node)
 def to_eobject(self: Node, resource: Resource, mappings=None):
+    if self is None:
+        return None
     if mappings is None:
         mappings = {}
-    eclass = resource.find_eclass(type(self))
+    elif id(self) in mappings:
+        return mappings[self]
+    eclass = resource.find_eclassifier(type(self))
     if not eclass:
-        raise Exception("Unknown eclass for " + str(type(self)))
+        raise Exception("Unknown classifier for " + str(type(self)))
     eobject = eclass()
+    mappings[id(self)] = eobject
+    for (p, v) in self.properties:
+        ev = translate_value(v, resource, mappings)
+        if isinstance(v, list):
+            eobject.eGet(p).extend(ev)
+        else:
+            eobject.eSet(p, ev)
     return eobject
+
+
+def translate_value(v, resource, mappings):
+    if isinstance(v, Enum):
+        enum_type = resource.find_eclassifier(type(v))
+        if enum_type:
+            return enum_type.getEEnumLiteral(v.name)
+        else:
+            raise Exception("Unknown enum " + str(type(v)))
+    if isinstance(v, list):
+        return [translate_value(x, resource, mappings) for x in v]
+    elif isinstance(v, Node):
+        return to_eobject(v, resource, mappings)
+    else:
+        return v
diff --git a/pylasu/model/__init__.py b/pylasu/model/__init__.py
@@ -1,4 +1,4 @@
-from .model import Node, Origin
+from .model import Node, Origin, internal_field, internal_properties
 from .position import Point, Position, pos
 from .traversing import walk, walk_leaves_first
 from .processing import children
diff --git a/pylasu/model/model.py b/pylasu/model/model.py
@@ -1,5 +1,6 @@
 import inspect
 from abc import ABC, abstractmethod
+from dataclasses import Field, MISSING
 from typing import Optional, Callable
 
 from .position import Position, Source
@@ -16,6 +17,19 @@ def decorate(cls: type):
     return decorate
 
 
+class InternalField(Field):
+    pass
+
+
+def internal_field(
+        *, default=MISSING, default_factory=MISSING, init=True, repr=True, hash=None, compare=True, metadata=None):
+    """Return an object to identify internal dataclass fields. The arguments are the same as dataclasses.field."""
+
+    if default is not MISSING and default_factory is not MISSING:
+        raise ValueError('cannot specify both default and default_factory')
+    return InternalField(default, default_factory, init, repr, hash, compare, metadata)
+
+
 class Origin(ABC):
     @internal_property
     @abstractmethod
@@ -32,14 +46,14 @@ def source(self) -> Optional[Source]:
 
 
 def is_internal_property_or_method(value):
-    return isinstance(value, internal_property) or isinstance(value, Callable)
+    return isinstance(value, internal_property) or isinstance(value, InternalField) or isinstance(value, Callable)
 
 
 class Node(Origin):
     origin: Optional[Origin] = None
     parent: Optional["Node"] = None
     position_override: Optional[Position] = None
-    __internal_properties__ = ["origin", "parent", "position"]
+    __internal_properties__ = ["origin", "parent", "position", "position_override"]
 
     def __init__(self, origin: Optional[Origin] = None, parent: Optional["Node"] = None,
                  position_override: Optional[Position] = None):
diff --git a/tests/test_model.py b/tests/test_model.py
@@ -106,15 +106,15 @@ def test_scope_lookup_4(self):
         upper_symbol = SomeSymbol(name='a', index=0)
         scope = Scope(symbols={'b': [SomeSymbol(name='b', index=0)]}, parent=Scope(symbols={'a': [upper_symbol]}))
         result = scope.lookup(symbol_name='a', symbol_type=SomeSymbol)
-        self.assertEquals(result, upper_symbol)
+        self.assertEqual(result, upper_symbol)
         self.assertIsInstance(result, SomeSymbol)
 
     def test_scope_lookup_5(self):
         """Symbol found in upper scope with name and type (local with different type)"""
         upper_symbol = SomeSymbol(name='a', index=0)
         scope = Scope(symbols={'a': [AnotherSymbol(name='a', index=0)]}, parent=Scope(symbols={'a': [upper_symbol]}))
         result = scope.lookup(symbol_name='a', symbol_type=SomeSymbol)
-        self.assertEquals(result, upper_symbol)
+        self.assertEqual(result, upper_symbol)
         self.assertIsInstance(result, SomeSymbol)
 
     def test_scope_lookup_6(self):
diff --git a/tests/test_processing.py b/tests/test_processing.py
@@ -38,8 +38,8 @@ def test_replace_in_list(self):
         b = BW(a1, [a2, a3])
         b.assign_parents()
         a2.replace_with(a4)
-        self.assertEquals("4", b.many_as[0].s)
-        self.assertEquals(BW(a1, [a4, a3]), b)
+        self.assertEqual("4", b.many_as[0].s)
+        self.assertEqual(BW(a1, [a4, a3]), b)
 
     def test_replace_in_set(self):
         a1 = AW("1")
@@ -56,4 +56,4 @@ def test_replace_single(self):
         b = BW(a1, [])
         b.assign_parents()
         a1.replace_with(a2)
-        self.assertEquals("2", b.a.s)
+        self.assertEqual("2", b.a.s)
diff --git a/tests/test_transpilation_trace.py b/tests/test_transpilation_trace.py
@@ -8,7 +8,7 @@
 from pylasu.emf import MetamodelBuilder
 from pylasu.playground import TranspilationTrace, ETranspilationTrace
 from pylasu.validation.validation import Result
-from tests.fixtures import Box
+from tests.fixtures import Box, Item
 
 nsURI = "http://mypackage.com"
 name = "StrumentaLanguageSupportTranspilationTest"
@@ -74,18 +74,42 @@ def test_serialize_transpilation_issue(self):
     def test_serialize_transpilation_from_nodes(self):
         mmb = MetamodelBuilder("tests.fixtures", "https://strumenta.com/pylasu/test/fixtures")
         mmb.provide_class(Box)
+        mmb.provide_class(Item)
 
         tt = TranspilationTrace(
-            original_code="box(a)[foo, bar]", generated_code='<box name="a"><foo /><bar /></box>',
-            source_result=Result(Box("a")),
-            target_result=Result(Box("a")))
+            original_code="box(a)[i1, bar]", generated_code='<box name="A"><i1 /><bar /></box>',
+            source_result=Result(Box("a", [Item("i1"), Box("b", [Item("i2"), Item("i3")])])),
+            target_result=Result(Box("A")))
 
         expected = """{
             "eClass": "https://strumenta.com/kolasu/transpilation/v1#//TranspilationTrace",
-            "generatedCode": "<box name=\\"a\\"><foo /><bar /></box>",
-            "originalCode": "box(a)[foo, bar]",
-            "sourceResult": {"root": {"eClass": "https://strumenta.com/pylasu/test/fixtures#//Box"}},
-            "targetResult": {"root": {"eClass": "https://strumenta.com/pylasu/test/fixtures#//Box"}}
+            "generatedCode": "<box name=\\"A\\"><i1 /><bar /></box>",
+            "originalCode": "box(a)[i1, bar]",
+            "sourceResult": { "root": {
+                "eClass": "https://strumenta.com/pylasu/test/fixtures#//Box",
+                "name": "a",
+                "contents": [{
+                    "eClass": "https://strumenta.com/pylasu/test/fixtures#//Item",
+                    "name": "i1"
+                    }, {
+                        "eClass": "https://strumenta.com/pylasu/test/fixtures#//Box",
+                        "name": "b",
+                        "contents": [{
+                            "eClass": "https://strumenta.com/pylasu/test/fixtures#//Item",
+                            "name": "i2"
+                        }, {
+                            "eClass": "https://strumenta.com/pylasu/test/fixtures#//Item",
+                            "name": "i3"
+                        }]
+                    }]
+                }
+            },
+            "targetResult": { "root": {
+                "eClass": "https://strumenta.com/pylasu/test/fixtures#//Box", 
+                "name": "A",
+                "contents": []
+                }
+            }
         }"""
         as_json = tt.save_as_json("foo.json", mmb.generate())
         self.assertEqual(json.loads(expected), json.loads(as_json))

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`		`-from .metamodel_builder import MetamodelBuilder`
`2`	`1`	`from .model import *`
	`2`	`+from .metamodel_builder import MetamodelBuilder`