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.
Files changed (100) hide show
  1. oort_lang/__init__.py +8 -0
  2. oort_lang/__main__.py +8 -0
  3. oort_lang/ast/__init__.py +1 -0
  4. oort_lang/ast/ast_visitor.py +188 -0
  5. oort_lang/ast/binding.py +44 -0
  6. oort_lang/ast/nodes/__init__.py +67 -0
  7. oort_lang/ast/nodes/adt.py +156 -0
  8. oort_lang/ast/nodes/argument.py +40 -0
  9. oort_lang/ast/nodes/assignment.py +23 -0
  10. oort_lang/ast/nodes/base.py +55 -0
  11. oort_lang/ast/nodes/call_expr.py +34 -0
  12. oort_lang/ast/nodes/class_def.py +67 -0
  13. oort_lang/ast/nodes/compiler_attr.py +17 -0
  14. oort_lang/ast/nodes/control_flow.py +131 -0
  15. oort_lang/ast/nodes/declarations.py +119 -0
  16. oort_lang/ast/nodes/expressions.py +93 -0
  17. oort_lang/ast/nodes/function_def.py +114 -0
  18. oort_lang/ast/nodes/import_stmt.py +48 -0
  19. oort_lang/ast/nodes/literal_constants.py +212 -0
  20. oort_lang/ast/nodes/lvalue.py +88 -0
  21. oort_lang/ast/nodes/macro.py +58 -0
  22. oort_lang/ast/nodes/module_node.py +25 -0
  23. oort_lang/ast/printer.py +159 -0
  24. oort_lang/bytecode/__init__.py +54 -0
  25. oort_lang/bytecode/code.py +102 -0
  26. oort_lang/bytecode/compile.py +607 -0
  27. oort_lang/bytecode/disasm.py +201 -0
  28. oort_lang/bytecode/opcodes.py +251 -0
  29. oort_lang/diagnostics/__init__.py +11 -0
  30. oort_lang/diagnostics/base.py +22 -0
  31. oort_lang/diagnostics/error_handler.py +171 -0
  32. oort_lang/diagnostics/error_listener.py +26 -0
  33. oort_lang/diagnostics/runtime_errors.py +23 -0
  34. oort_lang/diagnostics/syntax_errors.py +15 -0
  35. oort_lang/diagnostics/type_errors.py +7 -0
  36. oort_lang/driver/__init__.py +1 -0
  37. oort_lang/driver/arguments.py +89 -0
  38. oort_lang/driver/compiler.py +484 -0
  39. oort_lang/driver/logging_utils.py +22 -0
  40. oort_lang/driver/main.py +33 -0
  41. oort_lang/driver/repl.py +241 -0
  42. oort_lang/hir/__init__.py +104 -0
  43. oort_lang/hir/dump.py +188 -0
  44. oort_lang/hir/lower.py +1263 -0
  45. oort_lang/hir/nodes.py +474 -0
  46. oort_lang/parser/__init__.py +1 -0
  47. oort_lang/parser/ast_builder.py +558 -0
  48. oort_lang/parser/dialect.py +153 -0
  49. oort_lang/parser/expressions.py +306 -0
  50. oort_lang/parser/grammar/OortLexer.py +468 -0
  51. oort_lang/parser/grammar/OortParser.py +6467 -0
  52. oort_lang/parser/grammar/OortVisitor.py +483 -0
  53. oort_lang/parser/grammar/__init__.py +2 -0
  54. oort_lang/parser/literals.py +38 -0
  55. oort_lang/parser/names.py +16 -0
  56. oort_lang/parser/operator_defs.py +165 -0
  57. oort_lang/parser/parameters.py +219 -0
  58. oort_lang/parser/token_processor.py +114 -0
  59. oort_lang/runtime/__init__.py +73 -0
  60. oort_lang/runtime/builtins.py +162 -0
  61. oort_lang/runtime/bytecode_vm.py +1194 -0
  62. oort_lang/runtime/call_args.py +34 -0
  63. oort_lang/runtime/call_protocol.py +248 -0
  64. oort_lang/runtime/context.py +33 -0
  65. oort_lang/runtime/control_flow_exceptions.py +25 -0
  66. oort_lang/runtime/dispatch.py +136 -0
  67. oort_lang/runtime/environment.py +243 -0
  68. oort_lang/runtime/functions.py +265 -0
  69. oort_lang/runtime/host.py +35 -0
  70. oort_lang/runtime/interpreter.py +1290 -0
  71. oort_lang/runtime/modules.py +313 -0
  72. oort_lang/runtime/native.py +57 -0
  73. oort_lang/runtime/objects.py +596 -0
  74. oort_lang/runtime/signature.py +176 -0
  75. oort_lang/runtime/stdlib/__init__.py +35 -0
  76. oort_lang/runtime/stdlib/collections.py +80 -0
  77. oort_lang/runtime/stdlib/io_module.py +39 -0
  78. oort_lang/runtime/stdlib/math_module.py +96 -0
  79. oort_lang/runtime/stdlib/os_module.py +31 -0
  80. oort_lang/runtime/stdlib/string_module.py +106 -0
  81. oort_lang/runtime/type_system.py +575 -0
  82. oort_lang/semantics/__init__.py +1 -0
  83. oort_lang/semantics/analyzer.py +61 -0
  84. oort_lang/semantics/core/__init__.py +3 -0
  85. oort_lang/semantics/core/checker.py +1929 -0
  86. oort_lang/semantics/core/definite_assignment.py +266 -0
  87. oort_lang/semantics/core/types.py +258 -0
  88. oort_lang/semantics/decl.py +36 -0
  89. oort_lang/semantics/functions.py +221 -0
  90. oort_lang/semantics/pass1.py +325 -0
  91. oort_lang/semantics/resolution.py +73 -0
  92. oort_lang/semantics/scope.py +51 -0
  93. oort_lang/source/__init__.py +1 -0
  94. oort_lang/source/input_info.py +147 -0
  95. oort_lang/source/source_position.py +123 -0
  96. oort_lang-0.4.0.dist-info/METADATA +227 -0
  97. oort_lang-0.4.0.dist-info/RECORD +100 -0
  98. oort_lang-0.4.0.dist-info/WHEEL +4 -0
  99. oort_lang-0.4.0.dist-info/entry_points.txt +2 -0
  100. oort_lang-0.4.0.dist-info/licenses/LICENSE +21 -0
oort_lang/__init__.py ADDED
@@ -0,0 +1,8 @@
1
+ #! /usr/bin/env python
2
+
3
+ from importlib.metadata import PackageNotFoundError, version
4
+
5
+ try:
6
+ __version__ = version("oort-lang")
7
+ except PackageNotFoundError:
8
+ __version__ = "unknown"
oort_lang/__main__.py ADDED
@@ -0,0 +1,8 @@
1
+ #! /usr/bin/env python
2
+
3
+ """Allow `python -m oort_lang`."""
4
+
5
+ from .driver.main import main
6
+
7
+ if __name__ == "__main__":
8
+ main()
@@ -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)
@@ -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)