111 lines
2.9 KiB
Python
111 lines
2.9 KiB
Python
from core.builtin_concepts import BuiltinConcepts, ListConcept
|
|
from core.concept import Concept
|
|
import ast
|
|
|
|
import logging
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class NodeParent:
|
|
"""
|
|
Class that represent the ancestor of a Node
|
|
For example, the 'For' nodes has three fields (target, iter and body)
|
|
So, for a node under For.iter
|
|
node -> For
|
|
field -> iter
|
|
"""
|
|
|
|
def __init__(self, node, field):
|
|
self.node = node
|
|
self.field = field
|
|
|
|
def __repr__(self):
|
|
if self.node is None:
|
|
return None
|
|
|
|
if self.field is None:
|
|
return self.node.get_node_type()
|
|
|
|
return self.node.get_node_type() + "." + self.field
|
|
|
|
def __eq__(self, other):
|
|
# I can compare with type for simplification
|
|
if isinstance(other, tuple):
|
|
return self.node.get_node_type() == other[0] and self.field == other[1]
|
|
|
|
# normal equals implementation
|
|
if not isinstance(other, NodeParent):
|
|
return False
|
|
|
|
return self.node.get_node_type() == other.node.get_node_type() and self.field == other.field
|
|
|
|
def __hash__(self):
|
|
return hash((self.node.get_node_type(), self.field))
|
|
|
|
|
|
class NodeConcept(Concept):
|
|
def __init__(self, key, parent: NodeParent):
|
|
super().__init__(key, True, False, key)
|
|
self.parent = parent
|
|
|
|
def get_node_type(self):
|
|
return self.key
|
|
|
|
|
|
class GenericNodeConcept(NodeConcept):
|
|
def __init__(self, node_type, parent):
|
|
super().__init__(BuiltinConcepts.GENERIC_NODE, parent)
|
|
self.node_type = node_type
|
|
|
|
def __repr__(self):
|
|
return "Generic:" + self.node_type
|
|
|
|
def get_node_type(self):
|
|
return self.node_type
|
|
|
|
def get_value(self):
|
|
if self.node_type == "Name":
|
|
return self.get_prop("id")
|
|
|
|
if self.node_type == "arg":
|
|
return self.get_prop("arg")
|
|
|
|
return self.body
|
|
|
|
|
|
class IdentifierConcept(NodeConcept):
|
|
def __init__(self, parent, name):
|
|
super().__init__(BuiltinConcepts.IDENTIFIER_NODE, parent)
|
|
self.body = name
|
|
|
|
|
|
def transform(node):
|
|
"""
|
|
Transform Python AST node into concept nodes
|
|
for better usage
|
|
:param node:
|
|
:return:
|
|
"""
|
|
|
|
def _transform(node, parent):
|
|
node_type = node.__class__.__name__
|
|
concept = GenericNodeConcept(node_type, parent).init_key()
|
|
for field in node._fields:
|
|
if not hasattr(node, field):
|
|
continue
|
|
|
|
value = getattr(node, field)
|
|
if isinstance(value, list):
|
|
lst = ListConcept().init_key()
|
|
for i in value:
|
|
lst.append(_transform(i, NodeParent(concept, field)))
|
|
concept.set_prop(field, lst)
|
|
elif isinstance(value, ast.AST):
|
|
concept.set_prop(field, _transform(value, NodeParent(concept, field)))
|
|
else:
|
|
concept.set_prop(field, value)
|
|
return concept
|
|
|
|
return _transform(node, None)
|