jaclang 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

jaclang/compiler/parser.py

@@ -5,12 +5,14 @@ from __future__ import annotations
 import keyword
 import logging
 import os
+import sys
 from typing import Callable, Sequence, TYPE_CHECKING, TypeAlias, TypeVar, cast
 
 import jaclang.compiler.unitree as uni
-from jaclang.compiler import jac_lark as jl
+from jaclang.compiler import TOKEN_MAP, jac_lark as jl
 from jaclang.compiler.constant import EdgeDir, Tokens as Tok
 from jaclang.compiler.passes.main import Transform
+from jaclang.utils.helpers import ANSIColors
 from jaclang.vendor.lark import Lark, Transformer, Tree, logger
 
 if TYPE_CHECKING:
@@ -39,22 +41,17 @@ class JacParser(Transform[uni.Source, uni.Module]):
             tree, comments = JacParser.parse(ir_in.value, on_error=self.error_callback)
             mod = JacParser.TreeToAST(parser=self).transform(tree)
             ir_in.comments = [self.proc_comment(i, mod) for i in comments]
-            if isinstance(mod, uni.Module):
-                self.ir_out = mod
-                return mod
-            else:
+            if not isinstance(mod, uni.Module):
                 raise self.ice()
+            if len(self.errors_had) != 0:
+                mod.has_syntax_errors = True
+                self.report_errors()
+            self.ir_out = mod
+            return mod
         except jl.UnexpectedInput as e:
-            catch_error = uni.EmptyToken()
-            catch_error.orig_src = ir_in
-            catch_error.line_no = e.line
-            catch_error.end_line = e.line
-            catch_error.c_start = e.column
-            catch_error.c_end = e.column + 1
-            catch_error.pos_start = e.pos_in_stream or 0
-            catch_error.pos_end = catch_error.pos_start + 1
+            catch_error = self.error_to_token(e)
+            error_msg = self.error_to_message(e)
 
-            error_msg = "Syntax Error"
             if len(e.args) >= 1 and isinstance(e.args[0], str):
                 error_msg += e.args[0]
             self.log_error(error_msg, node_override=catch_error)
@@ -62,7 +59,12 @@ class JacParser(Transform[uni.Source, uni.Module]):
         except Exception as e:
             raise e
 
-        return uni.Module.make_stub(inject_src=ir_in)
+        # If we reach here, there was a syntax error, mark the module as such
+        # and report errors.
+        self.report_errors()
+        mod = uni.Module.make_stub(inject_src=ir_in)
+        mod.has_syntax_errors = True
+        return mod
 
     @staticmethod
     def proc_comment(token: jl.Token, mod: uni.UniNode) -> uni.CommentToken:
@@ -80,10 +82,114 @@ class JacParser(Transform[uni.Source, uni.Module]):
             kid=[],
         )
 
+    _MISSING_TOKENS = [
+        Tok.SEMI,
+        Tok.COMMA,
+        Tok.COLON,
+        Tok.RPAREN,
+        Tok.RBRACE,
+        Tok.RSQUARE,
+        Tok.RETURN_HINT,
+    ]
+
     def error_callback(self, e: jl.UnexpectedInput) -> bool:
         """Handle error."""
+        iparser = e.interactive_parser
+
+        def try_feed_missing_token(iparser: jl.InteractiveParser) -> Tok | None:
+            """Feed a missing token to the parser."""
+            # If any of the below token is missing, insert them and continue parsing.
+            accepts = iparser.accepts()
+            for tok in JacParser._MISSING_TOKENS:
+                if tok.name in accepts:
+                    iparser.feed_token(jl.Token(tok.name, TOKEN_MAP[tok.name]))
+                    return tok
+            return None
+
+        def feed_current_token(iparser: jl.InteractiveParser, tok: jl.Token) -> bool:
+            """Feed the current token to the parser."""
+            max_attempts = 100  # Prevent infinite loops
+            attempts = 0
+            while tok.type not in iparser.accepts():
+                if attempts >= max_attempts:
+                    return False  # Give up after too many attempts
+                if not try_feed_missing_token(iparser):
+                    return False
+                attempts += 1
+            iparser.feed_token(tok)
+            return True
+
+        if isinstance(e, jl.UnexpectedToken):
+            # If last token is DOT and we expect a NAME, insert a NAME token
+            last_tok: jl.Token | None = (
+                e.token_history[-1]
+                if e.token_history and len(e.token_history) >= 1
+                else None
+            )
+            if (
+                last_tok
+                and last_tok.type == Tok.DOT.name
+                and (Tok.NAME.name in e.accepts)
+            ):
+                self.log_error("Incomplete member access", self.error_to_token(e))
+                iparser.feed_token(jl.Token(Tok.NAME.name, "recover_name_token"))
+                return feed_current_token(iparser, e.token)
+
+            # We're calling try_feed_missing_token twice here because the first missing
+            # will be reported as such and we don't for the consequent missing token.
+            if tk := try_feed_missing_token(iparser):
+                self.log_error(f"Missing {tk.name}", self.error_to_token(e))
+                return feed_current_token(iparser, e.token)
+
+            # Ignore unexpected tokens and continue parsing till we reach a known state.
+            self.log_error(
+                f"Unexpected token '{e.token.value}'", self.error_to_token(e)
+            )
+            return True
+
         return False
 
+    def error_to_message(self, e: jl.UnexpectedInput) -> str:
+        """Return an error message based on the exception."""
+        # TODO: Match more specific errors with lark's example based matching.
+        # Reference: https://github.com/lark-parser/lark/blob/master/examples/advanced/error_reporting_lalr.py
+        # e.match_examples()
+        if isinstance(e, jl.UnexpectedToken):
+            return f"Unexpected token '{e.token.value}'"
+        return "Syntax Error"
+
+    def error_to_token(self, e: jl.UnexpectedInput) -> uni.Token:
+        """Convert error to token."""
+        catch_error = uni.EmptyToken()
+        catch_error.orig_src = self.ir_in
+        catch_error.line_no = e.line
+        catch_error.end_line = e.line
+        catch_error.c_start = e.column
+        catch_error.pos_start = e.pos_in_stream or 0
+        if isinstance(e, jl.UnexpectedToken) and e.token:
+            catch_error.c_end = e.token.end_column or (e.column + 1)
+            catch_error.pos_end = e.token.end_pos or (catch_error.pos_start + 1)
+        else:
+            catch_error.c_end = e.column + 1
+            catch_error.pos_end = catch_error.pos_start + 1
+        return catch_error
+
+    def report_errors(self, *, colors: bool = True) -> None:
+        """Report errors to the user."""
+        # TODO: Write a better IO system.
+        # NOTE: Currently it writes all the errors to stderr cause LSP JsonRPC uses stdout for IPC.
+        if not sys.stderr.isatty():
+            # FIXME: If we're outputting to a file (pipe, redirection, etc) other
+            # than a terminal we disable colors however we should be able to force
+            # colors with a configuration.
+            colors = False
+        for alrt in self.errors_had:
+            error_label = (
+                "Error:" if not colors else f"{ANSIColors.RED}Error:{ANSIColors.END}"
+            )
+            print(error_label, end=" ", file=sys.stderr)
+            print(alrt.pretty_print(colors=colors), file=sys.stderr)
+
     @staticmethod
     def _comment_callback(comment: jl.Token) -> None:
         JacParser.comment_cache.append(comment)
@@ -549,11 +655,12 @@ class JacParser(Transform[uni.Source, uni.Module]):
         def sem_def(self, _: None) -> uni.SemDef:
             """Grammar rule.
 
-            sem_def: KW_SEM dotted_name EQ multistring SEMI
+            sem_def: KW_SEM dotted_name (EQ | KW_IS) STRING SEMI
             """
             self.consume_token(Tok.KW_SEM)
             target = self.extract_from_list(self.consume(list), uni.NameAtom)
-            self.consume_token(Tok.EQ)
+            if not self.match_token(Tok.KW_IS):
+                self.consume_token(Tok.EQ)
             value = self.consume(uni.String)
             self.consume_token(Tok.SEMI)
             return uni.SemDef(
@@ -848,25 +955,104 @@ class JacParser(Transform[uni.Source, uni.Module]):
             if self.match_token(Tok.RETURN_HINT):
                 return_spec = self.consume(uni.Expr)
                 return uni.FuncSignature(
+                    posonly_params=[],
                     params=[],
+                    varargs=None,
+                    kwonlyargs=[],
+                    kwargs=None,
                     return_type=return_spec,
                     kid=self.flat_cur_nodes,
                 )
             # Otherwise, parse the traditional parameter list form
             else:
                 self.consume_token(Tok.LPAREN)
-                params = self.match(list)
+                all_params = self.match(list) or []
+                posonly_params, params, varargs, kwonlyargs, kwargs = (
+                    self._parse_parameter_categories(all_params)
+                )
                 self.consume_token(Tok.RPAREN)
                 if self.match_token(Tok.RETURN_HINT):
                     return_spec = self.consume(uni.Expr)
                 return uni.FuncSignature(
-                    params=(
-                        self.extract_from_list(params, uni.ParamVar) if params else []
-                    ),
+                    posonly_params=posonly_params,
+                    params=params,
+                    varargs=varargs,
+                    kwonlyargs=kwonlyargs,
+                    kwargs=kwargs,
                     return_type=return_spec,
                     kid=self.flat_cur_nodes,
                 )
 
+        def _parse_parameter_categories(self, all_params: list[uni.UniNode]) -> tuple[
+            list[uni.ParamVar],
+            list[uni.ParamVar],
+            uni.ParamVar | None,
+            list[uni.ParamVar],
+            uni.ParamVar | None,
+        ]:
+            posonly_params = []
+            params = []
+            varargs = None
+            kwonlyargs = []
+            kwargs = None
+
+            # Initial state determination
+            cur_state = "positional"
+            for param in all_params:
+                if isinstance(param, uni.Token) and param.name == Tok.DIV:
+                    cur_state = "posonly"
+                    break
+
+            for cur_nd in all_params:
+                cur_state = self._update_parameter_state(cur_nd, cur_state)
+                if isinstance(cur_nd, uni.ParamVar):
+                    if cur_state == "positional":
+                        cur_nd.param_kind = uni.ParamKind.NORMAL
+                        params.append(cur_nd)
+                    elif cur_state == "posonly":
+                        cur_nd.param_kind = uni.ParamKind.POSONLY
+                        posonly_params.append(cur_nd)
+                    elif cur_state == "varargs":
+                        cur_nd.param_kind = uni.ParamKind.VARARG
+                        varargs = cur_nd
+                        cur_state = "keyword_only"
+                    elif cur_state == "keyword_only":
+                        cur_nd.param_kind = uni.ParamKind.KWONLY
+                        kwonlyargs.append(cur_nd)
+                    elif cur_state == "kwargs":
+                        cur_nd.param_kind = uni.ParamKind.KWARG
+                        kwargs = cur_nd
+                    else:
+                        raise self.ice()
+
+            return posonly_params, params, varargs, kwonlyargs, kwargs
+
+        def _update_parameter_state(self, cur_nd: uni.UniNode, cur_state: str) -> str:
+            if isinstance(cur_nd, uni.Token):
+                if cur_nd.name == Tok.DIV:
+                    if cur_state in ["keyword_only", "kwargs", "positional"]:
+                        self.parse_ref.log_error(
+                            "Invalid syntax in function parameters: '/' cannot appear after '*' or '**'.",
+                            node_override=cur_nd,
+                        )
+                    return "positional"
+                elif cur_nd.name == Tok.STAR_MUL:
+                    if cur_state in ["keyword_only", "kwargs"]:
+                        self.parse_ref.log_error(
+                            "Invalid syntax in function parameters: '*' cannot appear after '**'.",
+                            node_override=cur_nd,
+                        )
+                    return "keyword_only"
+                elif cur_nd.name == Tok.COMMA:
+                    return cur_state
+
+            elif isinstance(cur_nd, uni.ParamVar):
+                if cur_nd.is_vararg:
+                    return "varargs"
+                if cur_nd.is_kwargs:
+                    return "kwargs"
+            return cur_state
+
         def func_decl_params(self, _: None) -> list[uni.UniNode]:
             """Grammar rule.
 
@@ -874,11 +1060,17 @@ class JacParser(Transform[uni.Source, uni.Module]):
             """
             return self.cur_nodes
 
-        def param_var(self, _: None) -> uni.ParamVar:
+        def param_var(self, _: None) -> uni.ParamVar | uni.Token:
             """Grammar rule.
 
-            param_var: (STAR_POW | STAR_MUL)? NAME type_tag (EQ expression)?
+            param_var: (STAR_POW | STAR_MUL)? named_ref type_tag (EQ expression)?
+                    | DIV
+                    | STAR_MUL
             """
+            if len(self.cur_nodes) == 1 and (
+                star_only := self.match_token(Tok.DIV) or self.match_token(Tok.STAR_MUL)
+            ):
+                return star_only
             star = self.match_token(Tok.STAR_POW) or self.match_token(Tok.STAR_MUL)
             name = self.consume(uni.Name)
             type_tag = self.consume(uni.SubTag)
@@ -1028,7 +1220,6 @@ class JacParser(Transform[uni.Source, uni.Module]):
                     | (yield_expr | KW_YIELD) SEMI
                     | raise_stmt SEMI
                     | assert_stmt SEMI
-                    | check_stmt SEMI
                     | assignment SEMI
                     | delete_stmt SEMI
                     | report_stmt SEMI
@@ -1307,18 +1498,6 @@ class JacParser(Transform[uni.Source, uni.Module]):
                 kid=self.cur_nodes,
             )
 
-        def check_stmt(self, _: None) -> uni.CheckStmt:
-            """Grammar rule.
-
-            check_stmt: KW_CHECK expression
-            """
-            self.consume_token(Tok.KW_CHECK)
-            target = self.consume(uni.Expr)
-            return uni.CheckStmt(
-                target=target,
-                kid=self.cur_nodes,
-            )
-
         def ctrl_stmt(self, _: None) -> uni.CtrlStmt | uni.DisengageStmt:
             """Grammar rule.
 
@@ -1532,29 +1711,40 @@ class JacParser(Transform[uni.Source, uni.Module]):
             lambda_expr: KW_LAMBDA func_decl_params? (RETURN_HINT expression)? COLON expression
             """
             return_type: uni.Expr | None = None
+            return_hint_tok: uni.Token | None = None
             sig_kid: list[uni.UniNode] = []
             self.consume_token(Tok.KW_LAMBDA)
             params = self.match(list)
-            if self.match_token(Tok.RETURN_HINT):
+            if return_hint_tok := self.match_token(Tok.RETURN_HINT):
                 return_type = self.consume(uni.Expr)
             self.consume_token(Tok.COLON)
             body = self.consume(uni.Expr)
             if params:
                 sig_kid.extend(params)
+            if return_hint_tok:
+                sig_kid.append(return_hint_tok)
             if return_type:
                 sig_kid.append(return_type)
             signature = (
                 uni.FuncSignature(
+                    posonly_params=[],
                     params=(
                         self.extract_from_list(params, uni.ParamVar) if params else []
                     ),
+                    varargs=None,
+                    kwonlyargs=[],
+                    kwargs=None,
                     return_type=return_type,
                     kid=sig_kid,
                 )
                 if params or return_type
                 else None
             )
-            new_kid = [i for i in self.cur_nodes if i != params and i != return_type]
+            new_kid = [
+                i
+                for i in self.cur_nodes
+                if i != params and i != return_type and i != return_hint_tok
+            ]
             new_kid.insert(1, signature) if signature else None
             return uni.LambdaExpr(
                 signature=signature,
@@ -1788,25 +1978,31 @@ class JacParser(Transform[uni.Source, uni.Module]):
                 )
             return self._binary_expr_unwind(self.cur_nodes)
 
+        def await_expr(self, _: None) -> uni.Expr:
+            """Grammar rule.
+
+            await_expr: KW_AWAIT? pipe_call
+            """
+            if self.match_token(Tok.KW_AWAIT):
+                operand = self.consume(uni.Expr)
+                return uni.AwaitExpr(
+                    target=operand,
+                    kid=self.cur_nodes,
+                )
+            return self._binary_expr_unwind(self.cur_nodes)
+
         def pipe_call(self, _: None) -> uni.Expr:
             """Grammar rule.
 
-            pipe_call: (PIPE_FWD | A_PIPE_FWD | KW_SPAWN | KW_AWAIT)? atomic_chain
+            pipe_call: (PIPE_FWD | A_PIPE_FWD | KW_SPAWN)? atomic_chain
             """
-            if len(self.cur_nodes) == 2:
-                if self.match_token(Tok.KW_AWAIT):
-                    target = self.consume(uni.Expr)
-                    return uni.AwaitExpr(
-                        target=target,
-                        kid=self.cur_nodes,
-                    )
-                elif op := self.match(uni.Token):
-                    operand = self.consume(uni.Expr)
-                    return uni.UnaryExpr(
-                        op=op,
-                        operand=operand,
-                        kid=self.cur_nodes,
-                    )
+            if len(self.cur_nodes) == 2 and (op := self.match(uni.Token)):
+                operand = self.consume(uni.Expr)
+                return uni.UnaryExpr(
+                    op=op,
+                    operand=operand,
+                    kid=self.cur_nodes,
+                )
             return self._binary_expr_unwind(self.cur_nodes)
 
         def aug_op(self, _: None) -> uni.Token:
@@ -1814,7 +2010,6 @@ class JacParser(Transform[uni.Source, uni.Module]):
 
             aug_op: RSHIFT_EQ
                    | LSHIFT_EQ
-                   | BW_NOT_EQ
                    | BW_XOR_EQ
                    | BW_OR_EQ
                    | BW_AND_EQ
@@ -1868,6 +2063,14 @@ class JacParser(Transform[uni.Source, uni.Module]):
             atomic_call: atomic_chain LPAREN param_list? by_llm? RPAREN
             """
             target = self.consume(uni.Expr)
+            gencompr = self.match(uni.GenCompr)
+            if gencompr:
+                return uni.FuncCall(
+                    target=target,
+                    params=[gencompr],
+                    genai_call=None,
+                    kid=self.cur_nodes,
+                )
             self.consume_token(Tok.LPAREN)
             params_sn = self.match(list)
             genai_call = self.match(uni.Expr)
@@ -2011,10 +2214,22 @@ class JacParser(Transform[uni.Source, uni.Module]):
 
             fstring: FSTR_START fstr_parts FSTR_END
                 | FSTR_SQ_START fstr_sq_parts FSTR_SQ_END
+                | FSTR_TRIPLE_START fstr_triple_parts FSTR_TRIPLE_END
+                | FSTR_SQ_TRIPLE_START fstr_sq_triple_parts FSTR_SQ_TRIPLE_END
             """
-            self.match_token(Tok.FSTR_START) or self.consume_token(Tok.FSTR_SQ_START)
+            (
+                self.match_token(Tok.FSTR_TRIPLE_START)
+                or self.match_token(Tok.FSTR_SQ_TRIPLE_START)
+                or self.match_token(Tok.FSTR_START)
+                or self.consume_token(Tok.FSTR_SQ_START)
+            )
             target = self.match(list)
-            self.match_token(Tok.FSTR_END) or self.consume_token(Tok.FSTR_SQ_END)
+            (
+                self.match_token(Tok.FSTR_TRIPLE_END)
+                or self.match_token(Tok.FSTR_SQ_TRIPLE_END)
+                or self.match_token(Tok.FSTR_END)
+                or self.consume_token(Tok.FSTR_SQ_END)
+            )
             return uni.FString(
                 parts=(
                     self.extract_from_list(target, (uni.String, uni.ExprStmt))
@@ -2062,6 +2277,44 @@ class JacParser(Transform[uni.Source, uni.Module]):
             ]
             return valid_parts
 
+        def fstr_triple_parts(self, _: None) -> list[uni.UniNode]:
+            """Grammar rule.
+
+            fstr_triple_parts: (FSTR_TRIPLE_PIECE | FSTR_BESC | LBRACE expression RBRACE )*
+            """
+            valid_parts: list[uni.UniNode] = [
+                (
+                    i
+                    if isinstance(i, uni.String)
+                    else (
+                        uni.ExprStmt(expr=i, in_fstring=True, kid=[i])
+                        if isinstance(i, uni.Expr)
+                        else i
+                    )
+                )
+                for i in self.cur_nodes
+            ]
+            return valid_parts
+
+        def fstr_sq_triple_parts(self, _: None) -> list[uni.UniNode]:
+            """Grammar rule.
+
+            fstr_sq_triple_parts: (FSTR_SQ_TRIPLE_PIECE | FSTR_BESC | LBRACE expression RBRACE )*
+            """
+            valid_parts: list[uni.UniNode] = [
+                (
+                    i
+                    if isinstance(i, uni.String)
+                    else (
+                        uni.ExprStmt(expr=i, in_fstring=True, kid=[i])
+                        if isinstance(i, uni.Expr)
+                        else i
+                    )
+                )
+                for i in self.cur_nodes
+            ]
+            return valid_parts
+
         def list_val(self, _: None) -> uni.ListVal:
             """Grammar rule.
 
@@ -2291,7 +2544,7 @@ class JacParser(Transform[uni.Source, uni.Module]):
         def assignment_list(self, _: None) -> list[uni.UniNode]:
             """Grammar rule.
 
-            assignment_list: (assignment_list COMMA)? (assignment | NAME)
+            assignment_list: (assignment | named_ref) (COMMA (assignment | named_ref))* COMMA?
             """
 
             def name_to_assign(name_consume: uni.NameAtom) -> uni.Assignment:
@@ -2299,15 +2552,23 @@ class JacParser(Transform[uni.Source, uni.Module]):
                     target=[name_consume], value=None, type_tag=None, kid=[name_consume]
                 )
 
-            if self.match(list):
-                self.consume_token(Tok.COMMA)
+            # Match first (assignment | named_ref)
             if self.match(uni.Assignment):
                 pass
             elif name_consume := self.match(uni.NameAtom):
                 self.cur_nodes[self.node_idx - 1] = name_to_assign(name_consume)
             else:
-                assign = self.consume(uni.Assignment)
-                self.cur_nodes[self.node_idx - 1] = assign
+                raise self.ice()
+
+            # Match (COMMA (assignment | named_ref))* COMMA?
+            while self.match_token(Tok.COMMA):
+                if self.match(uni.Assignment):
+                    pass
+                elif name_consume := self.match(uni.NameAtom):
+                    self.cur_nodes[self.node_idx - 1] = name_to_assign(name_consume)
+                else:
+                    break  # trailing comma
+
             return self.flat_cur_nodes
 
         def type_ref(self, kid: list[uni.UniNode]) -> uni.TypeRef:
@@ -2328,6 +2589,7 @@ class JacParser(Transform[uni.Source, uni.Module]):
             LSQUARE (KW_NODE| KW_EDGE)? expression? (edge_op_ref (filter_compr | expression)?)+ RSQUARE
             """
             self.consume_token(Tok.LSQUARE)
+            is_async = bool(self.match_token(Tok.KW_ASYNC))
             edges_only = bool(self.match_token(Tok.KW_EDGE))
             self.match_token(Tok.KW_NODE)
             valid_chain = []
@@ -2338,6 +2600,7 @@ class JacParser(Transform[uni.Source, uni.Module]):
             return uni.EdgeRefTrailer(
                 chain=valid_chain,
                 edges_only=edges_only,
+                is_async=is_async,
                 kid=self.cur_nodes,
             )
 
@@ -2767,6 +3030,36 @@ class JacParser(Transform[uni.Source, uni.Module]):
             value = self.consume(uni.MatchPattern)
             return uni.MatchKVPair(key=pattern, value=value, kid=self.cur_nodes)
 
+        def attr_pattern(self, _: None) -> uni.MatchValue:
+            """Grammar rule.
+
+            attr_pattern: NAME (DOT NAME)+
+            """
+            name_idx = 0
+            cur_element = self.consume(uni.NameAtom)
+            name_idx += 1
+            trailer: uni.AtomTrailer | None = None
+            while dot := self.match_token(Tok.DOT):
+                target = trailer if trailer else cur_element
+                right = self.consume(uni.NameAtom)
+                name_idx += 2
+                trailer = uni.AtomTrailer(
+                    target=target,
+                    right=right,
+                    is_attr=True,
+                    is_null_ok=False,
+                    kid=[target, dot, right],
+                )
+            name = trailer if trailer else cur_element
+            if not isinstance(name, (uni.NameAtom, uni.AtomTrailer)):
+                raise TypeError(
+                    f"Expected name to be either NameAtom or AtomTrailer, got {type(name)}"
+                )
+            return uni.MatchValue(
+                value=name,
+                kid=[name, *self.flat_cur_nodes[name_idx:]],
+            )
+
         def class_pattern(self, _: None) -> uni.MatchArch:
             """Grammar rule.
 
@@ -2873,6 +3166,8 @@ class JacParser(Transform[uni.Source, uni.Module]):
                 Tok.FSTR_BESC,
                 Tok.FSTR_PIECE,
                 Tok.FSTR_SQ_PIECE,
+                Tok.FSTR_TRIPLE_PIECE,
+                Tok.FSTR_SQ_TRIPLE_PIECE,
             ]:
                 ret_type = uni.String
                 if token.type == Tok.FSTR_BESC:

jaclang/compiler/passes/main/__init__.py

@@ -4,7 +4,6 @@ from ..transform import Alert, Transform  # noqa: I100
 from .annex_pass import JacAnnexPass  # noqa: I100
 from .binder_pass import BinderPass  # noqa: I100
 from .sym_tab_build_pass import SymTabBuildPass, UniPass  # noqa: I100
-from .sym_tab_link_pass import SymTabLinkPass  # noqa: I100
 from .def_use_pass import DefUsePass  # noqa: I100
 from .sem_def_match_pass import SemDefMatchPass  # noqa: I100
 from .import_pass import JacImportDepsPass  # noqa: I100
@@ -12,10 +11,10 @@ from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
 from .type_checker_pass import TypeCheckPass  # noqa: I100
 from .pyast_load_pass import PyastBuildPass  # type: ignore # noqa: I100
 from .pyast_gen_pass import PyastGenPass  # noqa: I100
+from .predynamo_pass import PreDynamoPass  # noqa: I100
 from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
 from .cfg_build_pass import CFGBuildPass  # noqa: I100
 from .pyjac_ast_link_pass import PyJacAstLinkPass  # noqa: I100
-from .inheritance_pass import InheritancePass  # noqa: I100
 
 
 __all__ = [
@@ -28,14 +27,13 @@ __all__ = [
     "BinderPass",
     "TypeCheckPass",
     "SymTabBuildPass",
-    "SymTabLinkPass",
     "DeclImplMatchPass",
     "DefUsePass",
     "SemDefMatchPass",
     "PyastBuildPass",
     "PyastGenPass",
+    "PreDynamoPass",
     "PyBytecodeGenPass",
     "CFGBuildPass",
     "PyJacAstLinkPass",
-    "InheritancePass",
 ]

jaclang/compiler/passes/main/def_use_pass.py

@@ -30,7 +30,6 @@ class DefUsePass(UniPass):
     """Jac Ast build pass."""
 
     def enter_archetype(self, node: uni.Archetype) -> None:
-        node.sym_tab.inherit_baseclasses_sym(node)
 
         def inform_from_walker(node: uni.UniNode) -> None:
             for i in (
@@ -38,6 +37,7 @@ class DefUsePass(UniPass):
                 + node.get_all_sub_nodes(uni.DisengageStmt)
                 + node.get_all_sub_nodes(uni.EdgeOpRef)
                 + node.get_all_sub_nodes(uni.EventSignature)
+                + node.get_all_sub_nodes(uni.TypedCtxBlock)
             ):
                 i.from_walker = True
 
@@ -47,9 +47,6 @@ class DefUsePass(UniPass):
                 if isinstance(i.body, uni.ImplDef):
                     inform_from_walker(i.body)
 
-    def enter_enum(self, node: uni.Enum) -> None:
-        node.sym_tab.inherit_baseclasses_sym(node)
-
     def enter_type_ref(self, node: uni.TypeRef) -> None:
         node.sym_tab.use_lookup(node)