L3.parse

  1from collections.abc import Sequence
  2from pathlib import Path
  3
  4from lark import Lark, Token, Transformer
  5from lark.visitors import v_args  # pyright: ignore[reportUnknownVariableType]
  6
  7from .syntax import (
  8    Abstract,
  9    Allocate,
 10    Apply,
 11    Begin,
 12    Branch,
 13    Identifier,
 14    Immediate,
 15    Let,
 16    LetRec,
 17    Load,
 18    Primitive,
 19    Program,
 20    Reference,
 21    Store,
 22    Term,
 23)
 24
 25
 26class AstTransformer(Transformer[Token, Program | Term]):
 27    @v_args(inline=True)
 28    def program(
 29        self,
 30        _program: Token,
 31        parameters: Sequence[Identifier],
 32        body: Term,
 33    ) -> Program:
 34        return Program(
 35            parameters=parameters,
 36            body=body,
 37        )
 38
 39    def parameters(
 40        self,
 41        parameters: Sequence[Token],
 42    ) -> Sequence[Identifier]:
 43        return [str(p) for p in parameters]
 44
 45    @v_args(inline=True)
 46    def term(
 47        self,
 48        term: Term,
 49    ) -> Term:
 50        return term
 51
 52    @v_args(inline=True)
 53    def let(
 54        self,
 55        _let: Token,
 56        bindings: Sequence[tuple[Identifier, Term]],
 57        body: Term,
 58    ) -> Term:
 59        return Let(
 60            bindings=bindings,
 61            body=body,
 62        )
 63
 64    @v_args(inline=True)
 65    def letrec(
 66        self,
 67        _letrec: Token,
 68        bindings: Sequence[tuple[Identifier, Term]],
 69        body: Term,
 70    ) -> Term:
 71        return LetRec(
 72            bindings=bindings,
 73            body=body,
 74        )
 75
 76    def bindings(
 77        self,
 78        bindings: Sequence[tuple[Identifier, Term]],
 79    ) -> Sequence[tuple[Identifier, Term]]:
 80        return bindings
 81
 82    @v_args(inline=True)
 83    def binding(
 84        self,
 85        name: Token,
 86        value: Term,
 87    ) -> tuple[Identifier, Term]:
 88        return str(name), value
 89
 90    @v_args(inline=True)
 91    def reference(
 92        self,
 93        name: Token,
 94    ) -> Term:
 95        return Reference(name=str(name))
 96
 97    @v_args(inline=True)
 98    def abstract(
 99        self,
100        _lambda: Token,
101        parameters: Sequence[Identifier],
102        body: Term,
103    ) -> Term:
104        return Abstract(
105            parameters=parameters,
106            body=body,
107        )
108
109    @v_args(inline=True)
110    def apply(
111        self,
112        target: Term,
113        *arguments: Term,
114    ) -> Term:
115        return Apply(
116            target=target,
117            arguments=list(arguments),
118        )
119
120    @v_args(inline=True)
121    def immediate(
122        self,
123        value: Token,
124    ) -> Term:
125        return Immediate(value=int(value))
126
127    @v_args(inline=True)
128    def primitive(
129        self,
130        operator: Token,
131        left: Term,
132        right: Term,
133    ) -> Term:
134        return Primitive(
135            operator=str(operator),  # type: ignore
136            left=left,
137            right=right,
138        )
139
140    @v_args(inline=True)
141    def branch(
142        self,
143        _if: Token,
144        operator: Token,
145        left: Term,
146        right: Term,
147        consequent: Term,
148        otherwise: Term,
149    ) -> Term:
150        return Branch(
151            operator=str(operator),  # type: ignore
152            left=left,
153            right=right,
154            consequent=consequent,
155            otherwise=otherwise,
156        )
157
158    @v_args(inline=True)
159    def allocate(
160        self,
161        _allocate: Token,
162        count: Immediate,
163    ) -> Term:
164        return Allocate(
165            count=count.value,
166        )
167
168    @v_args(inline=True)
169    def load(
170        self,
171        _load: Token,
172        base: Term,
173        index: Immediate,
174    ) -> Term:
175        return Load(
176            base=base,
177            index=index.value,
178        )
179
180    @v_args(inline=True)
181    def store(
182        self,
183        _store: Token,
184        base: Term,
185        index: Immediate,
186        value: Term,
187    ) -> Term:
188        return Store(
189            base=base,
190            index=index.value,
191            value=value,
192        )
193
194    def begin(
195        self,
196        args: Sequence[Token | Term],
197    ) -> Term:
198        # Filter out Token objects (like BEGIN token), keep only Terms
199        terms = [arg for arg in args if not isinstance(arg, Token)]
200        if len(terms) == 0:
201            raise ValueError("begin requires at least one term")
202        return Begin(
203            effects=terms[:-1],
204            value=terms[-1],
205        )
206
207
208def parse_term(source: str) -> Term:
209    grammar = Path(__file__).with_name("L3.lark").read_text()
210    parser = Lark(grammar, start="term")
211    tree = parser.parse(source)  # pyright: ignore[reportUnknownMemberType]
212    return AstTransformer().transform(tree)  # pyright: ignore[reportReturnType]
213
214
215def parse_program(source: str) -> Program:
216    grammar = Path(__file__).with_name("L3.lark").read_text()
217    parser = Lark(grammar, start="program")
218    tree = parser.parse(source)  # pyright: ignore[reportUnknownMemberType]
219    return AstTransformer().transform(tree)  # pyright: ignore[reportReturnType]