oort-lang 0.4.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- oort_lang/__init__.py +8 -0
- oort_lang/__main__.py +8 -0
- oort_lang/ast/__init__.py +1 -0
- oort_lang/ast/ast_visitor.py +188 -0
- oort_lang/ast/binding.py +44 -0
- oort_lang/ast/nodes/__init__.py +67 -0
- oort_lang/ast/nodes/adt.py +156 -0
- oort_lang/ast/nodes/argument.py +40 -0
- oort_lang/ast/nodes/assignment.py +23 -0
- oort_lang/ast/nodes/base.py +55 -0
- oort_lang/ast/nodes/call_expr.py +34 -0
- oort_lang/ast/nodes/class_def.py +67 -0
- oort_lang/ast/nodes/compiler_attr.py +17 -0
- oort_lang/ast/nodes/control_flow.py +131 -0
- oort_lang/ast/nodes/declarations.py +119 -0
- oort_lang/ast/nodes/expressions.py +93 -0
- oort_lang/ast/nodes/function_def.py +114 -0
- oort_lang/ast/nodes/import_stmt.py +48 -0
- oort_lang/ast/nodes/literal_constants.py +212 -0
- oort_lang/ast/nodes/lvalue.py +88 -0
- oort_lang/ast/nodes/macro.py +58 -0
- oort_lang/ast/nodes/module_node.py +25 -0
- oort_lang/ast/printer.py +159 -0
- oort_lang/bytecode/__init__.py +54 -0
- oort_lang/bytecode/code.py +102 -0
- oort_lang/bytecode/compile.py +607 -0
- oort_lang/bytecode/disasm.py +201 -0
- oort_lang/bytecode/opcodes.py +251 -0
- oort_lang/diagnostics/__init__.py +11 -0
- oort_lang/diagnostics/base.py +22 -0
- oort_lang/diagnostics/error_handler.py +171 -0
- oort_lang/diagnostics/error_listener.py +26 -0
- oort_lang/diagnostics/runtime_errors.py +23 -0
- oort_lang/diagnostics/syntax_errors.py +15 -0
- oort_lang/diagnostics/type_errors.py +7 -0
- oort_lang/driver/__init__.py +1 -0
- oort_lang/driver/arguments.py +89 -0
- oort_lang/driver/compiler.py +484 -0
- oort_lang/driver/logging_utils.py +22 -0
- oort_lang/driver/main.py +33 -0
- oort_lang/driver/repl.py +241 -0
- oort_lang/hir/__init__.py +104 -0
- oort_lang/hir/dump.py +188 -0
- oort_lang/hir/lower.py +1263 -0
- oort_lang/hir/nodes.py +474 -0
- oort_lang/parser/__init__.py +1 -0
- oort_lang/parser/ast_builder.py +558 -0
- oort_lang/parser/dialect.py +153 -0
- oort_lang/parser/expressions.py +306 -0
- oort_lang/parser/grammar/OortLexer.py +468 -0
- oort_lang/parser/grammar/OortParser.py +6467 -0
- oort_lang/parser/grammar/OortVisitor.py +483 -0
- oort_lang/parser/grammar/__init__.py +2 -0
- oort_lang/parser/literals.py +38 -0
- oort_lang/parser/names.py +16 -0
- oort_lang/parser/operator_defs.py +165 -0
- oort_lang/parser/parameters.py +219 -0
- oort_lang/parser/token_processor.py +114 -0
- oort_lang/runtime/__init__.py +73 -0
- oort_lang/runtime/builtins.py +162 -0
- oort_lang/runtime/bytecode_vm.py +1194 -0
- oort_lang/runtime/call_args.py +34 -0
- oort_lang/runtime/call_protocol.py +248 -0
- oort_lang/runtime/context.py +33 -0
- oort_lang/runtime/control_flow_exceptions.py +25 -0
- oort_lang/runtime/dispatch.py +136 -0
- oort_lang/runtime/environment.py +243 -0
- oort_lang/runtime/functions.py +265 -0
- oort_lang/runtime/host.py +35 -0
- oort_lang/runtime/interpreter.py +1290 -0
- oort_lang/runtime/modules.py +313 -0
- oort_lang/runtime/native.py +57 -0
- oort_lang/runtime/objects.py +596 -0
- oort_lang/runtime/signature.py +176 -0
- oort_lang/runtime/stdlib/__init__.py +35 -0
- oort_lang/runtime/stdlib/collections.py +80 -0
- oort_lang/runtime/stdlib/io_module.py +39 -0
- oort_lang/runtime/stdlib/math_module.py +96 -0
- oort_lang/runtime/stdlib/os_module.py +31 -0
- oort_lang/runtime/stdlib/string_module.py +106 -0
- oort_lang/runtime/type_system.py +575 -0
- oort_lang/semantics/__init__.py +1 -0
- oort_lang/semantics/analyzer.py +61 -0
- oort_lang/semantics/core/__init__.py +3 -0
- oort_lang/semantics/core/checker.py +1929 -0
- oort_lang/semantics/core/definite_assignment.py +266 -0
- oort_lang/semantics/core/types.py +258 -0
- oort_lang/semantics/decl.py +36 -0
- oort_lang/semantics/functions.py +221 -0
- oort_lang/semantics/pass1.py +325 -0
- oort_lang/semantics/resolution.py +73 -0
- oort_lang/semantics/scope.py +51 -0
- oort_lang/source/__init__.py +1 -0
- oort_lang/source/input_info.py +147 -0
- oort_lang/source/source_position.py +123 -0
- oort_lang-0.4.0.dist-info/METADATA +227 -0
- oort_lang-0.4.0.dist-info/RECORD +100 -0
- oort_lang-0.4.0.dist-info/WHEEL +4 -0
- oort_lang-0.4.0.dist-info/entry_points.txt +2 -0
- oort_lang-0.4.0.dist-info/licenses/LICENSE +21 -0
oort_lang/__init__.py
ADDED
oort_lang/__main__.py
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
@@ -0,0 +1,188 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from typing import Generic, TypeVar
|
|
4
|
+
|
|
5
|
+
T = TypeVar("T")
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
class ASTVisitor(Generic[T]):
|
|
9
|
+
def visit(self, node) -> T | None:
|
|
10
|
+
return node.accept(self)
|
|
11
|
+
|
|
12
|
+
def default_result(self) -> T | None:
|
|
13
|
+
return None
|
|
14
|
+
|
|
15
|
+
def aggregate_result(self, _aggregate: T | None, next_result: T | None) -> T | None:
|
|
16
|
+
return next_result
|
|
17
|
+
|
|
18
|
+
def pre_process(self, node):
|
|
19
|
+
pass
|
|
20
|
+
|
|
21
|
+
def post_process(self, node, result: T | None):
|
|
22
|
+
return result
|
|
23
|
+
|
|
24
|
+
def visit_children(self, node) -> T | None:
|
|
25
|
+
result = self.default_result()
|
|
26
|
+
if node is None:
|
|
27
|
+
return result
|
|
28
|
+
|
|
29
|
+
for child in node.children():
|
|
30
|
+
if child is None:
|
|
31
|
+
continue
|
|
32
|
+
child_result = child.accept(self)
|
|
33
|
+
result = self.aggregate_result(result, child_result)
|
|
34
|
+
|
|
35
|
+
return result
|
|
36
|
+
|
|
37
|
+
def visit_module(self, node) -> T | None:
|
|
38
|
+
return self.visit_children(node)
|
|
39
|
+
|
|
40
|
+
def visit_block_expr(self, node) -> T | None:
|
|
41
|
+
return self.visit_children(node)
|
|
42
|
+
|
|
43
|
+
def visit_compiler_attribute(self, node) -> T | None:
|
|
44
|
+
return self.visit_children(node)
|
|
45
|
+
|
|
46
|
+
def visit_var_decl(self, node) -> T | None:
|
|
47
|
+
return self.visit_children(node)
|
|
48
|
+
|
|
49
|
+
def visit_import_stmt(self, node) -> T | None:
|
|
50
|
+
return self.visit_children(node)
|
|
51
|
+
|
|
52
|
+
def visit_import_from_stmt(self, node) -> T | None:
|
|
53
|
+
return self.visit_children(node)
|
|
54
|
+
|
|
55
|
+
def visit_assignment(self, node) -> T | None:
|
|
56
|
+
return self.visit_children(node)
|
|
57
|
+
|
|
58
|
+
def visit_attribute(self, node) -> T | None:
|
|
59
|
+
return self.visit_children(node)
|
|
60
|
+
|
|
61
|
+
def visit_subscript(self, node) -> T | None:
|
|
62
|
+
return self.visit_children(node)
|
|
63
|
+
|
|
64
|
+
def visit_call(self, node) -> T | None:
|
|
65
|
+
return self.visit_children(node)
|
|
66
|
+
|
|
67
|
+
def visit_macro_call(self, node) -> T | None:
|
|
68
|
+
return self.visit_children(node)
|
|
69
|
+
|
|
70
|
+
def visit_await_expr(self, node) -> T | None:
|
|
71
|
+
return self.visit_children(node)
|
|
72
|
+
|
|
73
|
+
def visit_binary_expr(self, node) -> T | None:
|
|
74
|
+
return self.visit_children(node)
|
|
75
|
+
|
|
76
|
+
def visit_unary_expr(self, node) -> T | None:
|
|
77
|
+
return self.visit_children(node)
|
|
78
|
+
|
|
79
|
+
def visit_and_expr(self, node) -> T | None:
|
|
80
|
+
return self.visit_children(node)
|
|
81
|
+
|
|
82
|
+
def visit_or_expr(self, node) -> T | None:
|
|
83
|
+
return self.visit_children(node)
|
|
84
|
+
|
|
85
|
+
def visit_yield_expr(self, node) -> T | None:
|
|
86
|
+
return self.visit_children(node)
|
|
87
|
+
|
|
88
|
+
def visit_return_expr(self, node) -> T | None:
|
|
89
|
+
return self.visit_children(node)
|
|
90
|
+
|
|
91
|
+
def visit_continue_expr(self, node) -> T | None:
|
|
92
|
+
return self.visit_children(node)
|
|
93
|
+
|
|
94
|
+
def visit_break_expr(self, node) -> T | None:
|
|
95
|
+
return self.visit_children(node)
|
|
96
|
+
|
|
97
|
+
def visit_implicit_super_expr(self, node) -> T | None:
|
|
98
|
+
return self.visit_children(node)
|
|
99
|
+
|
|
100
|
+
def visit_class_def(self, node) -> T | None:
|
|
101
|
+
return self.visit_children(node)
|
|
102
|
+
|
|
103
|
+
def visit_enum_def(self, node) -> T | None:
|
|
104
|
+
return self.visit_children(node)
|
|
105
|
+
|
|
106
|
+
def visit_enum_constructor(self, node) -> T | None:
|
|
107
|
+
return self.visit_children(node)
|
|
108
|
+
|
|
109
|
+
def visit_enum_field(self, node) -> T | None:
|
|
110
|
+
return self.visit_children(node)
|
|
111
|
+
|
|
112
|
+
def visit_match_expr(self, node) -> T | None:
|
|
113
|
+
return self.visit_children(node)
|
|
114
|
+
|
|
115
|
+
def visit_match_arm(self, node) -> T | None:
|
|
116
|
+
return self.visit_children(node)
|
|
117
|
+
|
|
118
|
+
def visit_wildcard_pattern(self, node) -> T | None:
|
|
119
|
+
return self.visit_children(node)
|
|
120
|
+
|
|
121
|
+
def visit_name_pattern(self, node) -> T | None:
|
|
122
|
+
return self.visit_children(node)
|
|
123
|
+
|
|
124
|
+
def visit_constructor_pattern(self, node) -> T | None:
|
|
125
|
+
return self.visit_children(node)
|
|
126
|
+
|
|
127
|
+
def visit_function_def(self, node) -> T | None:
|
|
128
|
+
return self.visit_children(node)
|
|
129
|
+
|
|
130
|
+
def visit_macro_def(self, node) -> T | None:
|
|
131
|
+
return self.visit_children(node)
|
|
132
|
+
|
|
133
|
+
def visit_if_expr(self, node) -> T | None:
|
|
134
|
+
return self.visit_children(node)
|
|
135
|
+
|
|
136
|
+
def visit_for_expr(self, node) -> T | None:
|
|
137
|
+
return self.visit_children(node)
|
|
138
|
+
|
|
139
|
+
def visit_while_expr(self, node) -> T | None:
|
|
140
|
+
return self.visit_children(node)
|
|
141
|
+
|
|
142
|
+
def visit_argument(self, node) -> T | None:
|
|
143
|
+
return self.visit_children(node)
|
|
144
|
+
|
|
145
|
+
def visit_parameter(self, node) -> T | None:
|
|
146
|
+
return self.visit_children(node)
|
|
147
|
+
|
|
148
|
+
def visit_type_parameter(self, node) -> T | None:
|
|
149
|
+
return self.visit_children(node)
|
|
150
|
+
|
|
151
|
+
def visit_single_decl_target(self, node) -> T | None:
|
|
152
|
+
return self.visit_children(node)
|
|
153
|
+
|
|
154
|
+
def visit_list_literal(self, node) -> T | None:
|
|
155
|
+
return self.visit_children(node)
|
|
156
|
+
|
|
157
|
+
def visit_tuple_literal(self, node) -> T | None:
|
|
158
|
+
return self.visit_children(node)
|
|
159
|
+
|
|
160
|
+
def visit_set_literal(self, node) -> T | None:
|
|
161
|
+
return self.visit_children(node)
|
|
162
|
+
|
|
163
|
+
def visit_dict_literal(self, node) -> T | None:
|
|
164
|
+
return self.visit_children(node)
|
|
165
|
+
|
|
166
|
+
def visit_slice_literal(self, node) -> T | None:
|
|
167
|
+
return self.visit_children(node)
|
|
168
|
+
|
|
169
|
+
def visit_int_constant(self, node) -> T | None:
|
|
170
|
+
return self.visit_children(node)
|
|
171
|
+
|
|
172
|
+
def visit_float_constant(self, node) -> T | None:
|
|
173
|
+
return self.visit_children(node)
|
|
174
|
+
|
|
175
|
+
def visit_string_constant(self, node) -> T | None:
|
|
176
|
+
return self.visit_children(node)
|
|
177
|
+
|
|
178
|
+
def visit_boolean_constant(self, node) -> T | None:
|
|
179
|
+
return self.visit_children(node)
|
|
180
|
+
|
|
181
|
+
def visit_null_constant(self, node) -> T | None:
|
|
182
|
+
return self.visit_children(node)
|
|
183
|
+
|
|
184
|
+
def visit_ellipsis_constant(self, node) -> T | None:
|
|
185
|
+
return self.visit_children(node)
|
|
186
|
+
|
|
187
|
+
def visit_name(self, node) -> T | None:
|
|
188
|
+
return self.visit_children(node)
|
oort_lang/ast/binding.py
ADDED
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
"""Resolved-name bindings attached to AST nodes."""
|
|
4
|
+
|
|
5
|
+
import dataclasses
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
@dataclasses.dataclass(frozen=True, slots=True)
|
|
9
|
+
class Binding:
|
|
10
|
+
"""Where a name is resolved.
|
|
11
|
+
|
|
12
|
+
`depth` is the number of lexical scopes between the use site and the
|
|
13
|
+
defining scope; `None` means the global scope. `index` is the name's slot
|
|
14
|
+
in that scope layout and is `None` for globals.
|
|
15
|
+
|
|
16
|
+
The slot index is not used by the tree-walking interpreter yet. It is
|
|
17
|
+
carried here so a later slot/upvalue backend can consume the same binding
|
|
18
|
+
without re-resolving names.
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
name: str
|
|
22
|
+
depth: int | None = None
|
|
23
|
+
index: int | None = None
|
|
24
|
+
|
|
25
|
+
def __post_init__(self):
|
|
26
|
+
if self.depth is None:
|
|
27
|
+
if self.index is not None:
|
|
28
|
+
raise ValueError("A global binding cannot have a slot index")
|
|
29
|
+
elif self.index is None:
|
|
30
|
+
raise ValueError("A local binding requires a slot index")
|
|
31
|
+
elif self.depth < 0 or self.index < 0:
|
|
32
|
+
raise ValueError("Binding depth and index must be non-negative")
|
|
33
|
+
|
|
34
|
+
@property
|
|
35
|
+
def is_global(self) -> bool:
|
|
36
|
+
return self.depth is None
|
|
37
|
+
|
|
38
|
+
@classmethod
|
|
39
|
+
def global_binding(cls, name: str) -> "Binding":
|
|
40
|
+
return cls(name=name)
|
|
41
|
+
|
|
42
|
+
@classmethod
|
|
43
|
+
def local(cls, name: str, depth: int, index: int) -> "Binding":
|
|
44
|
+
return cls(name=name, depth=depth, index=index)
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from .adt import (
|
|
4
|
+
ConstructorPattern,
|
|
5
|
+
EnumConstructor,
|
|
6
|
+
EnumDef,
|
|
7
|
+
EnumField,
|
|
8
|
+
MatchArm,
|
|
9
|
+
MatchExpr,
|
|
10
|
+
NamePattern,
|
|
11
|
+
Pattern,
|
|
12
|
+
WildcardPattern,
|
|
13
|
+
)
|
|
14
|
+
from .argument import Argument, ArgumentKind
|
|
15
|
+
from .assignment import Assignment
|
|
16
|
+
from .base import ASTNode
|
|
17
|
+
from .call_expr import Call
|
|
18
|
+
from .class_def import ClassDef, ImplicitSuperExpr
|
|
19
|
+
from .compiler_attr import CompilerAttribute
|
|
20
|
+
from .control_flow import (
|
|
21
|
+
AwaitExpr,
|
|
22
|
+
BreakExpr,
|
|
23
|
+
ContinueExpr,
|
|
24
|
+
ForExpr,
|
|
25
|
+
IfExpr,
|
|
26
|
+
ReturnExpr,
|
|
27
|
+
WhileExpr,
|
|
28
|
+
YieldExpr,
|
|
29
|
+
)
|
|
30
|
+
from .declarations import (
|
|
31
|
+
Declaration,
|
|
32
|
+
Parameter,
|
|
33
|
+
ParameterKind,
|
|
34
|
+
SingleDeclTarget,
|
|
35
|
+
TypeParameter,
|
|
36
|
+
VarDecl,
|
|
37
|
+
)
|
|
38
|
+
from .expressions import (
|
|
39
|
+
AndExpr,
|
|
40
|
+
BinaryExpr,
|
|
41
|
+
BlockExpr,
|
|
42
|
+
BooleanExpr,
|
|
43
|
+
Expression,
|
|
44
|
+
OrExpr,
|
|
45
|
+
StmtExpr,
|
|
46
|
+
UnaryExpr,
|
|
47
|
+
)
|
|
48
|
+
from .function_def import FunctionDef
|
|
49
|
+
from .import_stmt import ImportFromStmt, ImportStmt
|
|
50
|
+
from .literal_constants import (
|
|
51
|
+
BooleanConstant,
|
|
52
|
+
Constant,
|
|
53
|
+
DictLiteral,
|
|
54
|
+
EllipsisConstant,
|
|
55
|
+
FloatConstant,
|
|
56
|
+
IntConstant,
|
|
57
|
+
ListLiteral,
|
|
58
|
+
Literal,
|
|
59
|
+
NullConstant,
|
|
60
|
+
SetLiteral,
|
|
61
|
+
SliceLiteral,
|
|
62
|
+
StringConstant,
|
|
63
|
+
TupleLiteral,
|
|
64
|
+
)
|
|
65
|
+
from .lvalue import Attribute, LValue, LValueContext, Name, Subscript
|
|
66
|
+
from .macro import MacroCall, MacroDef
|
|
67
|
+
from .module_node import ModuleNode
|
|
@@ -0,0 +1,156 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from collections.abc import Iterable
|
|
4
|
+
|
|
5
|
+
from antlr4 import ParserRuleContext
|
|
6
|
+
|
|
7
|
+
from ...source.source_position import SourcePosition
|
|
8
|
+
from ..ast_visitor import ASTVisitor
|
|
9
|
+
from .base import ASTNode
|
|
10
|
+
from .declarations import TypeParameter
|
|
11
|
+
from .expressions import StmtExpr
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class EnumDef(StmtExpr):
|
|
15
|
+
"""A monomorphic tagged-union declaration."""
|
|
16
|
+
|
|
17
|
+
def __init__(
|
|
18
|
+
self,
|
|
19
|
+
context: ParserRuleContext,
|
|
20
|
+
name: str,
|
|
21
|
+
type_params: Iterable[TypeParameter],
|
|
22
|
+
constructors: Iterable["EnumConstructor"],
|
|
23
|
+
name_position: SourcePosition,
|
|
24
|
+
):
|
|
25
|
+
super().__init__(context)
|
|
26
|
+
self.name = name
|
|
27
|
+
self.type_params = list(type_params)
|
|
28
|
+
self.constructors = list(constructors)
|
|
29
|
+
self.name_position = name_position
|
|
30
|
+
|
|
31
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
32
|
+
for index, type_param in enumerate(self.type_params):
|
|
33
|
+
yield f"type_param {index}", type_param
|
|
34
|
+
for index, constructor in enumerate(self.constructors):
|
|
35
|
+
yield f"constructor {index}", constructor
|
|
36
|
+
|
|
37
|
+
def _accept(self, visitor: ASTVisitor):
|
|
38
|
+
return visitor.visit_enum_def(self)
|
|
39
|
+
|
|
40
|
+
def str_attrs(self) -> str | None:
|
|
41
|
+
return f"name={self.name!r}"
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
class EnumConstructor(ASTNode):
|
|
45
|
+
"""One enum variant, optionally with named payload fields."""
|
|
46
|
+
|
|
47
|
+
def __init__(
|
|
48
|
+
self,
|
|
49
|
+
context: ParserRuleContext,
|
|
50
|
+
name: str,
|
|
51
|
+
fields: Iterable["EnumField"],
|
|
52
|
+
):
|
|
53
|
+
super().__init__(context)
|
|
54
|
+
self.name = name
|
|
55
|
+
self.fields = list(fields)
|
|
56
|
+
|
|
57
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
58
|
+
for index, field in enumerate(self.fields):
|
|
59
|
+
yield f"field {index}", field
|
|
60
|
+
|
|
61
|
+
def _accept(self, visitor: ASTVisitor):
|
|
62
|
+
return visitor.visit_enum_constructor(self)
|
|
63
|
+
|
|
64
|
+
def str_attrs(self) -> str | None:
|
|
65
|
+
return f"name={self.name!r}"
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
class EnumField(ASTNode):
|
|
69
|
+
def __init__(self, context: ParserRuleContext, name: str, type_expr: ASTNode | None):
|
|
70
|
+
super().__init__(context)
|
|
71
|
+
self.name = name
|
|
72
|
+
self.type_expr = type_expr
|
|
73
|
+
|
|
74
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
75
|
+
yield "type_expr", self.type_expr
|
|
76
|
+
|
|
77
|
+
def _accept(self, visitor: ASTVisitor):
|
|
78
|
+
return visitor.visit_enum_field(self)
|
|
79
|
+
|
|
80
|
+
def str_attrs(self) -> str | None:
|
|
81
|
+
return f"name={self.name!r}"
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
class MatchExpr(StmtExpr):
|
|
85
|
+
def __init__(
|
|
86
|
+
self,
|
|
87
|
+
context: ParserRuleContext,
|
|
88
|
+
scrutinee: ASTNode,
|
|
89
|
+
arms: Iterable["MatchArm"],
|
|
90
|
+
):
|
|
91
|
+
super().__init__(context)
|
|
92
|
+
self.scrutinee = scrutinee
|
|
93
|
+
self.arms = list(arms)
|
|
94
|
+
|
|
95
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
96
|
+
yield "scrutinee", self.scrutinee
|
|
97
|
+
for index, arm in enumerate(self.arms):
|
|
98
|
+
yield f"arm {index}", arm
|
|
99
|
+
|
|
100
|
+
def _accept(self, visitor: ASTVisitor):
|
|
101
|
+
return visitor.visit_match_expr(self)
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
class MatchArm(ASTNode):
|
|
105
|
+
def __init__(self, context: ParserRuleContext, pattern: "Pattern", body: ASTNode):
|
|
106
|
+
super().__init__(context)
|
|
107
|
+
self.pattern = pattern
|
|
108
|
+
self.body = body
|
|
109
|
+
|
|
110
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
111
|
+
yield "pattern", self.pattern
|
|
112
|
+
yield "body", self.body
|
|
113
|
+
|
|
114
|
+
def _accept(self, visitor: ASTVisitor):
|
|
115
|
+
return visitor.visit_match_arm(self)
|
|
116
|
+
|
|
117
|
+
|
|
118
|
+
class Pattern(ASTNode):
|
|
119
|
+
def _accept(self, visitor: ASTVisitor):
|
|
120
|
+
raise RuntimeError("Should not be called")
|
|
121
|
+
|
|
122
|
+
|
|
123
|
+
class WildcardPattern(Pattern):
|
|
124
|
+
def _accept(self, visitor: ASTVisitor):
|
|
125
|
+
return visitor.visit_wildcard_pattern(self)
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
class NamePattern(Pattern):
|
|
129
|
+
"""A binding name, or a nullary constructor when resolved by the checker."""
|
|
130
|
+
|
|
131
|
+
def __init__(self, context: ParserRuleContext, name: str):
|
|
132
|
+
super().__init__(context)
|
|
133
|
+
self.name = name
|
|
134
|
+
|
|
135
|
+
def _accept(self, visitor: ASTVisitor):
|
|
136
|
+
return visitor.visit_name_pattern(self)
|
|
137
|
+
|
|
138
|
+
def str_attrs(self) -> str | None:
|
|
139
|
+
return f"name={self.name!r}"
|
|
140
|
+
|
|
141
|
+
|
|
142
|
+
class ConstructorPattern(Pattern):
|
|
143
|
+
def __init__(self, context: ParserRuleContext, name: str, args: Iterable[Pattern]):
|
|
144
|
+
super().__init__(context)
|
|
145
|
+
self.name = name
|
|
146
|
+
self.args = list(args)
|
|
147
|
+
|
|
148
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
149
|
+
for index, arg in enumerate(self.args):
|
|
150
|
+
yield f"arg {index}", arg
|
|
151
|
+
|
|
152
|
+
def _accept(self, visitor: ASTVisitor):
|
|
153
|
+
return visitor.visit_constructor_pattern(self)
|
|
154
|
+
|
|
155
|
+
def str_attrs(self) -> str | None:
|
|
156
|
+
return f"name={self.name!r}"
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from collections.abc import Iterable
|
|
4
|
+
from enum import Enum
|
|
5
|
+
|
|
6
|
+
from antlr4 import ParserRuleContext
|
|
7
|
+
|
|
8
|
+
from ..ast_visitor import ASTVisitor
|
|
9
|
+
from .base import ASTNode
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class ArgumentKind(Enum):
|
|
13
|
+
"""Function call argument kinds."""
|
|
14
|
+
|
|
15
|
+
INVALID = 0
|
|
16
|
+
DEFAULT = 1 # arg1
|
|
17
|
+
KEYWORD = 2 # name=arg2
|
|
18
|
+
VAR_POS = 3 # *args
|
|
19
|
+
VAR_KW = 4 # **kwargs
|
|
20
|
+
BLOCK = 5 # f() do {}
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
class Argument(ASTNode):
|
|
24
|
+
def __init__(
|
|
25
|
+
self,
|
|
26
|
+
context: ParserRuleContext,
|
|
27
|
+
value: ASTNode,
|
|
28
|
+
kind: ArgumentKind = ArgumentKind.DEFAULT,
|
|
29
|
+
keyword: str | None = None,
|
|
30
|
+
):
|
|
31
|
+
super().__init__(context)
|
|
32
|
+
self.value = value
|
|
33
|
+
self.kind = kind
|
|
34
|
+
self.keyword = keyword
|
|
35
|
+
|
|
36
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
37
|
+
yield "value", self.value
|
|
38
|
+
|
|
39
|
+
def _accept(self, visitor: ASTVisitor):
|
|
40
|
+
return visitor.visit_argument(self)
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from collections.abc import Iterable
|
|
4
|
+
|
|
5
|
+
from antlr4 import ParserRuleContext, Token
|
|
6
|
+
|
|
7
|
+
from ..ast_visitor import ASTVisitor
|
|
8
|
+
from .base import ASTNode
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class Assignment(ASTNode):
|
|
12
|
+
def __init__(self, context: ParserRuleContext, op: Token, lhs: ASTNode, rhs: ASTNode):
|
|
13
|
+
super().__init__(context)
|
|
14
|
+
self.op = op
|
|
15
|
+
self.lhs = lhs
|
|
16
|
+
self.rhs = rhs
|
|
17
|
+
|
|
18
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
19
|
+
yield "lhs", self.lhs
|
|
20
|
+
yield "rhs", self.rhs
|
|
21
|
+
|
|
22
|
+
def _accept(self, visitor: ASTVisitor):
|
|
23
|
+
return visitor.visit_assignment(self)
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from collections.abc import Iterable
|
|
4
|
+
from typing import TYPE_CHECKING, Any, Optional
|
|
5
|
+
|
|
6
|
+
from antlr4 import ParserRuleContext, Token
|
|
7
|
+
|
|
8
|
+
from ...source.source_position import SourcePosition
|
|
9
|
+
from ..ast_visitor import ASTVisitor, T
|
|
10
|
+
|
|
11
|
+
if TYPE_CHECKING:
|
|
12
|
+
from ..binding import Binding
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class ASTNode:
|
|
16
|
+
def __init__(self, context: SourcePosition | ParserRuleContext | Token):
|
|
17
|
+
if isinstance(context, ParserRuleContext):
|
|
18
|
+
position = SourcePosition.from_context(context)
|
|
19
|
+
elif isinstance(context, Token):
|
|
20
|
+
position = SourcePosition.from_token(context)
|
|
21
|
+
else:
|
|
22
|
+
position = context
|
|
23
|
+
assert isinstance(position, SourcePosition)
|
|
24
|
+
self.position = position
|
|
25
|
+
|
|
26
|
+
# Filled in by pass 1 for name-like nodes (`Name`, `ImplicitSuperExpr`).
|
|
27
|
+
self.binding: Binding | None = None
|
|
28
|
+
|
|
29
|
+
self.metadata: dict[str, Any] = {}
|
|
30
|
+
|
|
31
|
+
@property
|
|
32
|
+
def node_type(self):
|
|
33
|
+
return type(self).__name__
|
|
34
|
+
|
|
35
|
+
def children(self) -> Iterable["ASTNode"]:
|
|
36
|
+
for _, child in self.named_children():
|
|
37
|
+
if child is not None:
|
|
38
|
+
yield child
|
|
39
|
+
|
|
40
|
+
def named_children(self) -> Iterable[tuple[str, Optional["ASTNode"]]]:
|
|
41
|
+
return []
|
|
42
|
+
|
|
43
|
+
def __iter__(self):
|
|
44
|
+
return iter(self.children())
|
|
45
|
+
|
|
46
|
+
def _accept(self, visitor: ASTVisitor[T]) -> T:
|
|
47
|
+
raise NotImplementedError()
|
|
48
|
+
|
|
49
|
+
def accept(self, visitor: ASTVisitor[T]) -> T:
|
|
50
|
+
visitor.pre_process(self)
|
|
51
|
+
result = self._accept(visitor)
|
|
52
|
+
return visitor.post_process(self, result)
|
|
53
|
+
|
|
54
|
+
def str_attrs(self) -> str | None:
|
|
55
|
+
return None
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from collections.abc import Iterable
|
|
4
|
+
|
|
5
|
+
from antlr4 import ParserRuleContext, Token
|
|
6
|
+
|
|
7
|
+
from ...source.source_position import SourcePosition
|
|
8
|
+
from ..ast_visitor import ASTVisitor
|
|
9
|
+
from .argument import Argument
|
|
10
|
+
from .base import ASTNode
|
|
11
|
+
from .expressions import Expression
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class Call(Expression):
|
|
15
|
+
def __init__(
|
|
16
|
+
self,
|
|
17
|
+
context: SourcePosition | ParserRuleContext | Token,
|
|
18
|
+
func: ASTNode,
|
|
19
|
+
args: Iterable[Argument],
|
|
20
|
+
infix: bool = False,
|
|
21
|
+
):
|
|
22
|
+
super().__init__(context)
|
|
23
|
+
self.func = func
|
|
24
|
+
# todo: normalize all type of args (and trailing block) here?
|
|
25
|
+
self.args = [arg for arg in args]
|
|
26
|
+
self.infix = infix
|
|
27
|
+
|
|
28
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
29
|
+
yield "func", self.func
|
|
30
|
+
for index, arg in enumerate(self.args):
|
|
31
|
+
yield f"arg {index}", arg
|
|
32
|
+
|
|
33
|
+
def _accept(self, visitor: ASTVisitor):
|
|
34
|
+
return visitor.visit_call(self)
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
#! /usr/bin/env python
|
|
2
|
+
|
|
3
|
+
from collections.abc import Iterable
|
|
4
|
+
|
|
5
|
+
from antlr4 import ParserRuleContext
|
|
6
|
+
|
|
7
|
+
from ...source.source_position import SourcePosition
|
|
8
|
+
from ..ast_visitor import ASTVisitor
|
|
9
|
+
from .base import ASTNode
|
|
10
|
+
from .declarations import TypeParameter
|
|
11
|
+
from .expressions import BlockExpr, Expression, StmtExpr
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class ClassDef(StmtExpr):
|
|
15
|
+
def __init__(
|
|
16
|
+
self,
|
|
17
|
+
context: ParserRuleContext,
|
|
18
|
+
names: Iterable[str],
|
|
19
|
+
type_params: Iterable[TypeParameter],
|
|
20
|
+
bases: Iterable[Expression],
|
|
21
|
+
meta: Expression | None,
|
|
22
|
+
body: BlockExpr,
|
|
23
|
+
name_position: SourcePosition,
|
|
24
|
+
):
|
|
25
|
+
super().__init__(context)
|
|
26
|
+
self.names = [name for name in names]
|
|
27
|
+
self.type_params = [type_param for type_param in type_params]
|
|
28
|
+
self.bases = [base for base in bases]
|
|
29
|
+
self.meta = meta
|
|
30
|
+
self.body = body
|
|
31
|
+
self.name_position = name_position
|
|
32
|
+
|
|
33
|
+
def named_children(self) -> Iterable[tuple[str, ASTNode | None]]:
|
|
34
|
+
for index, type_param in enumerate(self.type_params):
|
|
35
|
+
yield f"type_param {index}", type_param
|
|
36
|
+
for index, base in enumerate(self.bases):
|
|
37
|
+
yield f"base {index}", base
|
|
38
|
+
if self.meta:
|
|
39
|
+
yield "meta", self.meta
|
|
40
|
+
yield "body", self.body
|
|
41
|
+
|
|
42
|
+
def _accept(self, visitor: ASTVisitor):
|
|
43
|
+
return visitor.visit_class_def(self)
|
|
44
|
+
|
|
45
|
+
def str_attrs(self) -> str | None:
|
|
46
|
+
return f"name={self.full_name!r}"
|
|
47
|
+
|
|
48
|
+
@property
|
|
49
|
+
def name(self) -> str:
|
|
50
|
+
if not self.names:
|
|
51
|
+
return "<lambda>"
|
|
52
|
+
return self.names[-1]
|
|
53
|
+
|
|
54
|
+
@property
|
|
55
|
+
def full_name(self) -> str:
|
|
56
|
+
if not self.names:
|
|
57
|
+
return "<lambda>"
|
|
58
|
+
return ".".join(self.names)
|
|
59
|
+
|
|
60
|
+
@property
|
|
61
|
+
def is_lambda(self) -> bool:
|
|
62
|
+
return not self.names
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
class ImplicitSuperExpr(Expression):
|
|
66
|
+
def _accept(self, visitor: ASTVisitor):
|
|
67
|
+
return visitor.visit_implicit_super_expr(self)
|