Working on AST Generation

Author: ftomassetti

pylasu/lionweb/ast_generation.py

@@ -1,26 +1,40 @@
 import ast
+import keyword
 from pathlib import Path
 from typing import cast, List, Dict
 
 import astor  # Install with `pip install astor`
 import click
-from lionwebpython.language import Language, Concept, Interface
+from lionwebpython.language import Language, Concept, Interface, Containment, Property
+from lionwebpython.language.classifier import Classifier
 from lionwebpython.language.enumeration import Enumeration
 from lionwebpython.language.primitive_type import PrimitiveType
+from lionwebpython.language.reference import Reference
 from lionwebpython.lionweb_version import LionWebVersion
 from lionwebpython.serialization.serialization_provider import SerializationProvider
 
 from pylasu.lionweb.starlasu import StarLasuBaseLanguage
 
 
-def topological_concepts_sort(concepts: List[Concept]) -> List[Concept]:
-    id_to_concept = {el.get_id(): el for el in concepts}
+def topological_classifiers_sort(classifiers: List[Classifier]) -> List[Classifier]:
+    id_to_concept = {el.get_id(): el for el in classifiers}
 
     # Build graph edges: child -> [parents]
-    graph: Dict[str, List[str]] = {el.get_id(): [] for el in concepts}
-    for el in concepts:
-        if el.get_extended_concept() and el.get_extended_concept().get_id() in id_to_concept:
-            graph[el.get_id()].append(el.get_extended_concept().get_id())
+    graph: Dict[str, List[str]] = {el.get_id(): [] for el in classifiers}
+    for c in classifiers:
+        if isinstance(c, Concept):
+            if c.get_extended_concept() and c.get_extended_concept().get_id() in id_to_concept:
+                graph[c.get_id()].append(c.get_extended_concept().get_id())
+            for i in c.get_implemented():
+                graph[c.get_id()].append(i.get_id())
+            for f in c.get_features():
+                if isinstance(f, Containment):
+                    if f.get_type() and f.get_type().get_id() in id_to_concept:
+                        graph[c.get_id()].append(f.get_type().get_id())
+        elif isinstance(c, Interface):
+            pass
+        else:
+            raise ValueError()
 
     visited = set()
     sorted_list = []
@@ -29,12 +43,14 @@ def visit(name: str):
         if name in visited:
             return
         visited.add(name)
-        for dep in graph[name]:
-            visit(dep)
-        sorted_list.append(id_to_concept[name])
+        if name in graph:
+            for dep in graph[name]:
+                visit(dep)
+        if name in id_to_concept:
+            sorted_list.append(id_to_concept[name])
 
-    for el in concepts:
-        visit(el.get_id())
+    for c in classifiers:
+        visit(c.get_id())
 
     return sorted_list
 
@@ -65,12 +81,30 @@ def main(dependencies, lionweb_language, output):
         names=[ast.alias(name='ABC', asname=None)],
         level=0
     )
+    import_dataclass = ast.ImportFrom(
+        module='dataclasses',
+        names=[ast.alias(name='dataclass', asname=None)],
+        level=0
+    )
+    import_starlasu = ast.ImportFrom(
+        module='pylasu.model.metamodel',
+        names=[ast.alias(name='Expression', asname='StarLasuExpression'),
+               ast.alias(name='PlaceholderElement', asname='StarLasuPlaceholderElement'),
+               ast.alias(name='Named', asname='StarLasuNamed'),
+               ast.alias(name='TypeAnnotation', asname='StarLasuTypeAnnotation'),
+               ast.alias(name='Parameter', asname='StarLasuParameter'),
+               ast.alias(name='Statement', asname='StarLasuStatement'),
+               ast.alias(name='EntityDeclaration', asname='StarLasuEntityDeclaration'),
+               ast.alias(name='BehaviorDeclaration', asname='StarLasuBehaviorDeclaration'),
+               ast.alias(name='Documentation', asname='StarLasuDocumentation')],
+        level=0
+    )
     import_node = ast.ImportFrom(
         module='pylasu.model',
         names=[ast.alias(name='Node', asname=None)],
         level=0
     )
-    module = ast.Module(body=[import_abc, import_node], type_ignores=[])
+    module = ast.Module(body=[import_abc, import_dataclass, import_starlasu, import_node], type_ignores=[])
 
 
     for element in language.get_elements():
@@ -85,21 +119,79 @@ def main(dependencies, lionweb_language, output):
         else:
             raise ValueError(f"Unsupported {element}")
 
-    sorted_concepts = topological_concepts_sort([c for c in language.get_elements() if isinstance(c, Concept)])
-
-    for concept in sorted_concepts:
-        bases = []
-        if concept.get_extended_concept().id == StarLasuBaseLanguage.get_astnode(LionWebVersion.V2023_1).id:
-            bases.append('Node')
+    sorted_classifier = topological_classifiers_sort([c for c in language.get_elements() if isinstance(c, Classifier)])
+
+    for classifier in sorted_classifier:
+        if isinstance(classifier, Concept):
+            bases = []
+            if classifier.get_extended_concept().id == StarLasuBaseLanguage.get_astnode(LionWebVersion.V2023_1).id:
+                bases.append('Node')
+            else:
+                bases.append(classifier.get_extended_concept().get_name())
+            for i in classifier.get_implemented():
+                if i.get_id() == 'com-strumenta-StarLasu-Expression-id':
+                    bases.append('StarLasuExpression')
+                elif i.get_id() == 'com-strumenta-StarLasu-Statement-id':
+                    bases.append('StarLasuStatement')
+                elif i.get_id() == 'com-strumenta-StarLasu-PlaceholderElement-id':
+                    bases.append('StarLasuPlaceholderElement')
+                elif i.get_id() == 'com-strumenta-StarLasu-Parameter-id':
+                    bases.append('StarLasuParameter')
+                elif i.get_id() == 'com-strumenta-StarLasu-Documentation-id':
+                    bases.append('StarLasuDocumentation')
+                elif i.get_id() == 'com-strumenta-StarLasu-TypeAnnotation-id':
+                    bases.append('StarLasuTypeAnnotation')
+                elif i.get_id() == 'com-strumenta-StarLasu-BehaviorDeclaration-id':
+                    bases.append('StarLasuBehaviorDeclaration')
+                elif i.get_id() == 'com-strumenta-StarLasu-EntityDeclaration-id':
+                    bases.append('StarLasuEntityDeclaration')
+                elif i.get_id() == 'LionCore-builtins-INamed':
+                    bases.append('StarLasuNamed')
+                else:
+                    bases.append(i.get_name())
+            if classifier.is_abstract():
+                bases.append('ABC')
+            dataclass_decorator = ast.Name(id="dataclass", ctx=ast.Load())
+            classdef = ast.ClassDef(classifier.get_name(), bases=bases,
+                keywords=[],
+                body=[ast.Pass()],
+                decorator_list=[dataclass_decorator])
+
+            for feature in classifier.get_features():
+                if isinstance(feature, Containment):
+                    field_name = feature.get_name()
+                    if field_name in keyword.kwlist:
+                        field_name = f"{field_name}_"
+                    field = ast.AnnAssign(
+                        target=ast.Name(id=field_name, ctx=ast.Store()),
+                        annotation=ast.Constant(value=feature.get_type().get_name()),
+                        value=None,
+                        simple=1,
+                    )
+                    if len(classdef.body) == 1 and isinstance(classdef.body[0], ast.Pass):
+                        classdef.body = []
+                    classdef.body.append(field)
+                elif isinstance(feature, Reference):
+                    pass
+                elif isinstance(feature, Property):
+                    pass
+                else:
+                    raise ValueError()
+
+            module.body.append(classdef)
+        elif isinstance(classifier, Interface):
+            bases=[]
+            if len(classifier.get_extended_interfaces()) == 0:
+                bases.append("Node")
+                bases.append("ABC")
+
+            classdef = ast.ClassDef(classifier.get_name(), bases=bases,
+                keywords=[],
+                body=[ast.Pass()],
+                decorator_list=[])
+            module.body.append(classdef)
         else:
-            bases.append(concept.get_extended_concept().get_name())
-        if concept.is_abstract():
-            bases.append('ABC')
-        classdef = ast.ClassDef(concept.get_name(), bases=bases,
-            keywords=[],
-            body=[ast.Pass()],
-            decorator_list=[])
-        module.body.append(classdef)
+            raise ValueError()
 
     click.echo(f"📂 Saving results to: {output}")
     generated_code = astor.to_source(module)

pylasu/model/metamodel.py

@@ -0,0 +1,32 @@
+from abc import ABC
+
+
+class Expression(ABC):
+    pass
+
+class PlaceholderElement(ABC):
+    pass
+
+class TypeAnnotation(ABC):
+    pass
+
+class Parameter(ABC):
+    pass
+
+class Statement(ABC):
+    pass
+
+class EntityDeclaration(ABC):
+    pass
+
+class BehaviorDeclaration(ABC):
+    pass
+
+class Documentation(ABC):
+    pass
+
+class Named(ABC):
+
+    @property
+    def name(self) -> str:
+        pass