monty/parser.py at main · code-visible/monty · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
import ast
import os

from nodes import Abstract, Call, Callabale


class Parser:
    name: str
    path: str
    deps: dict[str, any]
    fns: dict[str, Callabale]
    absts: dict[str, Abstract]
    cs: list[Call]
    ast: any
    file: any
    lookup: any
    visited_set: set

    """Class representing a parser"""

    def __init__(self, file: any, lookup: any):
        self.name = file.name
        self.path = file.dir.path
        self.ast = file.ast
        self.file = file
        self.deps = {}
        self.fns = {}
        self.absts = {}
        self.cs = []
        self.visited_set = set()
        self.lookup = lookup

    def parse_source(self):
        for node in ast.walk(self.ast):
            self.parse_node(node)

        self.post_walk()

    def post_walk(self):
        for fn in self.fns.values():
            if fn.method:
                fn.abstract = self.absts.get(fn.abstract).id
            else:
                fn.abstract = ""

    def parse_node(self, node):
        if isinstance(node, ast.Import):
            self.parse_import(node)
        elif isinstance(node, ast.ImportFrom):
            self.parse_import_from(node)
        elif isinstance(node, ast.FunctionDef):
            self.parse_function_def(node)
        elif isinstance(node, ast.ClassDef):
            self.parse_class_def(node)
        elif isinstance(node, ast.Call):
            self.parse_call(node)

    def parse_import(self, node):
        for alias in node.names:
            key = alias.asname if alias.asname is not None else alias.name
            lookup_name = os.path.join(self.path, alias.name.replace(".", "/"))
            r = self.lookup(lookup_name + "__init__", 2)
            if r is not None:
                self.deps[key] = r
            else:
                r = self.lookup(lookup_name, 2)
                if r is not None:
                    self.deps[key] = r

    def try_import_pkg(self, key: str, pkg: str, names: any):
        match = False
        # match files
        for alias in names:
            key = alias.asname if alias.asname is not None else alias.name
            lookup_name = os.path.join(pkg, alias.name)
            r = self.lookup(lookup_name, 2)
            if r is not None:
                self.deps[key] = r
                match = True

        if not match:
            lookup_name = os.path.join(pkg, "__init__")
            r = self.lookup(lookup_name, 2)
            if r is not None:
                self.deps[key] = r
            # match file
            else:
                r = self.lookup(pkg, 2)
                if r is not None:
                    self.deps[key] = r

    def parse_import_from(self, node):
        if node.level > 0:
            relative_path = "../" * (node.level - 1) + (
                node.module.replace(".", "/") if node.module else ""
            )
            key = ""
            if node.module:
                keys: list = node.module.split(".")
                key = keys[len(keys) - 1]
            lookup_name = os.path.normpath(os.path.join(self.path, relative_path))
            # lookup the package
            # perhaps: from package import file, from package import function(__init__), from package.package import xx
            r = self.lookup(lookup_name, 0)
            if r is not None:
                self.try_import_pkg(key, lookup_name, node.names)

        else:
            # lookup_name = os.path.normpath(os.path.join(self.path, node.module.replace('.', '/')))
            lookup_name = os.path.normpath(node.module.replace(".", "/"))
            keys: list = node.module.split(".")
            key = keys[len(keys) - 1]
            r = self.lookup(lookup_name, 0)
            if r is not None:
                self.try_import_pkg(key, lookup_name, node.names)

    def parse_function_def(self, node):
        if node in self.visited_set:
            return
        fn = Callabale("", node, self.file)
        self.fns[node.name] = fn

    def parse_class_def(self, node):
        fields = []
        for body_item in node.body:
            if isinstance(body_item, ast.Assign):
                for target in body_item.targets:
                    if isinstance(target, ast.Name):
                        fields.append(target.id)

            elif isinstance(body_item, ast.FunctionDef):
                fn = Callabale(node.name, body_item, self.file)
                self.fns["%s.%s" % (node.name, body_item.name)] = fn
                self.visited_set.add(body_item)

            self.absts[node.name] = Abstract(node, fields, self.file)

    def parse_call(self, node):
        if not isinstance(node.func, ast.Name):
            return
        # arg_values = [ast.dump(arg) for arg in node.args]
        # callee = node.func.id
        # self.cs.append(Call("callerA", callee, "typ", node, self.file))
        # TODO: impl call, save decl in stack to pop up the caller
        pass