From a38574eb1f413d8b1e987d73f87b536f8b14b922 Mon Sep 17 00:00:00 2001 From: marsninja Date: Thu, 16 Nov 2023 08:17:33 -0500 Subject: [PATCH 1/9] New comment approach --- jaclang/jac/absyntree.py | 6 +- jaclang/jac/parser.py | 18 ++++- jaclang/jac/passes/main/__init__.py | 2 - jaclang/jac/passes/main/schedules.py | 5 -- .../passes/main/tests/test_jac_format_pass.py | 6 +- jaclang/jac/passes/tool/__init__.py | 3 +- jaclang/jac/passes/tool/fuse_comments_pass.py | 65 +++++++++++++++++++ .../{main => tool}/jac_formatter_pass.py | 4 ++ jaclang/jac/passes/tool/schedules.py | 10 +++ .../tool/tests/test_fuse_comments_pass.py | 23 +++++++ jaclang/jac/transpiler.py | 4 +- 11 files changed, 132 insertions(+), 14 deletions(-) create mode 100644 jaclang/jac/passes/tool/fuse_comments_pass.py rename jaclang/jac/passes/{main => tool}/jac_formatter_pass.py (99%) create mode 100644 jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py diff --git a/jaclang/jac/absyntree.py b/jaclang/jac/absyntree.py index a85f3d76d..2175e46ab 100644 --- a/jaclang/jac/absyntree.py +++ b/jaclang/jac/absyntree.py @@ -2149,6 +2149,10 @@ class Semi(Token, CodeBlockStmt): """Semicolon node type for Jac Ast.""" +class CommentToken(Token): + """CommentToken node type for Jac Ast.""" + + # ---------------- class JacSource(EmptyToken): """SourceString node type for Jac Ast.""" @@ -2158,7 +2162,7 @@ def __init__(self, source: str, mod_path: str) -> None: super().__init__() self.value = source self.file_path = mod_path - self.comments: list[jl.Token] = [] + self.comments: list[CommentToken] = [] @property def code(self) -> str: diff --git a/jaclang/jac/parser.py b/jaclang/jac/parser.py index ebdbb918c..9563bf7e1 100644 --- a/jaclang/jac/parser.py +++ b/jaclang/jac/parser.py @@ -30,10 +30,11 @@ def __init__(self, input_ir: ast.JacSource) -> None: def transform(self, ir: ast.AstNode) -> ast.AstNode: """Transform input IR.""" try: - tree, self.source.comments = JacParser.parse( + tree, comments = JacParser.parse( self.source.value, on_error=self.error_callback ) mod: ast.AstNode = JacParser.TreeToAST(parser=self).transform(tree) + self.source.comments = [self.proc_comment(i, mod) for i in comments] except jl.UnexpectedInput as e: catch_error = ast.EmptyToken() catch_error.file_path = self.mod_path @@ -47,6 +48,21 @@ def transform(self, ir: ast.AstNode) -> ast.AstNode: self.error(f"Internal Error: {e}") return mod + @staticmethod + def proc_comment(token: jl.Token, mod: ast.AstNode) -> ast.CommentToken: + """Process comment.""" + return ast.CommentToken( + file_path=mod.loc.mod_path, + name=token.type, + value=token.value, + line=token.line if token.line is not None else 0, + col_start=token.column if token.column is not None else 0, + col_end=token.end_column if token.end_column is not None else 0, + pos_start=token.start_pos if token.start_pos is not None else 0, + pos_end=token.end_pos if token.end_pos is not None else 0, + kid=[], + ) + def error_callback(self, e: jl.UnexpectedInput) -> bool: """Handle error.""" return False diff --git a/jaclang/jac/passes/main/__init__.py b/jaclang/jac/passes/main/__init__.py index 0bc363589..45c2876ed 100644 --- a/jaclang/jac/passes/main/__init__.py +++ b/jaclang/jac/passes/main/__init__.py @@ -5,7 +5,6 @@ from .def_impl_match_pass import DeclDefMatchPass # noqa: I100 from .def_use_pass import DefUsePass # noqa: I100 from .pyout_pass import PyOutPass # noqa: I100 -from .jac_formatter_pass import JacFormatPass # noqa: I100 from .pyast_load_pass import PyastBuildPass # noqa: I100 from .pyast_gen_pass import PyastGenPass # noqa: I100 from .schedules import py_code_gen # noqa: I100 @@ -20,7 +19,6 @@ "DeclDefMatchPass", "DefUsePass", "PyOutPass", - "JacFormatPass", "PyastBuildPass", "PyastGenPass", ] diff --git a/jaclang/jac/passes/main/schedules.py b/jaclang/jac/passes/main/schedules.py index 3011502a6..6c2bc3b07 100644 --- a/jaclang/jac/passes/main/schedules.py +++ b/jaclang/jac/passes/main/schedules.py @@ -4,16 +4,13 @@ """ from __future__ import annotations -from typing import Type -from ..ir_pass import Pass from .sub_node_tab_pass import SubNodeTabPass # noqa: I100 from .import_pass import ImportPass # noqa: I100 from .sym_tab_build_pass import SymTabBuildPass # noqa: I100 from .def_impl_match_pass import DeclDefMatchPass # noqa: I100 from .def_use_pass import DefUsePass # noqa: I100 from .pyout_pass import PyOutPass # noqa: I100 -from .jac_formatter_pass import JacFormatPass # noqa: I100 from .pyast_gen_pass import PyastGenPass # noqa: I100 py_code_gen = [ @@ -29,5 +26,3 @@ *py_code_gen, PyOutPass, ] - -format_pass: list[Type[Pass]] = [JacFormatPass] diff --git a/jaclang/jac/passes/main/tests/test_jac_format_pass.py b/jaclang/jac/passes/main/tests/test_jac_format_pass.py index cc36c0392..aa48d6108 100644 --- a/jaclang/jac/passes/main/tests/test_jac_format_pass.py +++ b/jaclang/jac/passes/main/tests/test_jac_format_pass.py @@ -1,9 +1,11 @@ """Test ast build pass module.""" import ast as ast3 -from jaclang.jac.passes.main import JacFormatPass + from jaclang.jac.passes.main import PyastGenPass from jaclang.jac.passes.main.schedules import py_code_gen as without_format +from jaclang.jac.passes.tool.schedules import format_pass +from jaclang.jac.passes.tool import JacFormatPass from jaclang.jac.transpiler import jac_file_to_pass, jac_str_to_pass from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite @@ -38,7 +40,7 @@ def micro_suite_test(self, filename: str) -> None: target=PyastGenPass, schedule=without_format, ) - with_format = [JacFormatPass] + with_format = format_pass code_gen_format = jac_file_to_pass( self.fixture_abs_path(filename), schedule=with_format ) diff --git a/jaclang/jac/passes/tool/__init__.py b/jaclang/jac/passes/tool/__init__.py index 6fff4e3b6..b9ac3668c 100644 --- a/jaclang/jac/passes/tool/__init__.py +++ b/jaclang/jac/passes/tool/__init__.py @@ -4,11 +4,12 @@ SymbolTableDotGraphPass, SymbolTablePrinterPass, ) - +from .jac_formatter_pass import JacFormatPass # noqa: I100 __all__ = [ "AstDotGraphPass", "AstPrinterPass", "SymbolTablePrinterPass", "SymbolTableDotGraphPass", + "JacFormatPass", ] diff --git a/jaclang/jac/passes/tool/fuse_comments_pass.py b/jaclang/jac/passes/tool/fuse_comments_pass.py new file mode 100644 index 000000000..90dc5cb53 --- /dev/null +++ b/jaclang/jac/passes/tool/fuse_comments_pass.py @@ -0,0 +1,65 @@ +"""JacFormatPass for Jaseci Ast. + +This is a pass for formatting Jac code. +""" + +from typing import Any, List, Tuple + +import jaclang.jac.absyntree as ast +from jaclang.jac.constant import Constants as Con +from jaclang.jac.constant import Tokens as Tok +from jaclang.jac.passes import Pass + + +class FuseCommentsPass(Pass): + """JacFormat Pass format Jac code.""" + + def before_pass(self) -> None: + self.all_tokens: list[ast.Token] = [] + self.comments: list[ast.Token] = ( + self.ir.source.comments if isinstance(self.ir, ast.Module) else [] + ) + return super().before_pass() + + def exit_node(self, node: ast.AstNode) -> None: + """Exit node.""" + if isinstance(node, ast.Token): + self.all_tokens.append(node) + + def after_pass(self) -> None: + """Insert comment tokens into all_tokens.""" + marker = 0 + new_tokens: list[ast.Token] = [] + for i in range(len(self.all_tokens)): + new_tokens.append(self.all_tokens[i]) + if i >= len(self.all_tokens) - 1: + break + if marker >= len(self.comments): + new_tokens.extend(self.all_tokens[i + 1 :]) + break + elif ( + self.all_tokens[i].loc.first_line + <= self.comments[marker].loc.first_line + or self.all_tokens[i].loc.col_start + <= self.comments[marker].loc.col_start + ) and ( + self.all_tokens[i + 1].loc.last_line + >= self.comments[marker].loc.last_line + or self.all_tokens[i + 1].loc.col_end + >= self.comments[marker].loc.col_end + ): + new_tokens.append(self.comments[marker]) + marker += 1 + + for i in range(len(new_tokens)): + if isinstance(new_tokens[i], ast.CommentToken): + if i == 0: + self.ir.add_kids_left([new_tokens[i]]) + continue + new_val = new_tokens[i - 1] + if new_val.parent is not None: + new_kids = new_val.parent.kid + new_kids.insert(new_kids.index(new_val), new_tokens[i]) + new_val.parent.set_kids(new_kids) + else: + raise self.ice("Token without parent in AST should be impossible") diff --git a/jaclang/jac/passes/main/jac_formatter_pass.py b/jaclang/jac/passes/tool/jac_formatter_pass.py similarity index 99% rename from jaclang/jac/passes/main/jac_formatter_pass.py rename to jaclang/jac/passes/tool/jac_formatter_pass.py index a4b63c9d4..5ea800b5e 100644 --- a/jaclang/jac/passes/main/jac_formatter_pass.py +++ b/jaclang/jac/passes/tool/jac_formatter_pass.py @@ -1793,3 +1793,7 @@ def exit_null(self, node: ast.Null) -> None: def exit_semi(self, node: ast.Semi) -> None: """Sub objects.""" self.emit(node, node.value) + + def exit_comment_token(self, node: ast.CommentToken) -> None: + """Sub objects.""" + \ No newline at end of file diff --git a/jaclang/jac/passes/tool/schedules.py b/jaclang/jac/passes/tool/schedules.py index 32cde0524..2231047b7 100644 --- a/jaclang/jac/passes/tool/schedules.py +++ b/jaclang/jac/passes/tool/schedules.py @@ -1,4 +1,7 @@ """Pass schedules.""" +from typing import Type + +from ..ir_pass import Pass from jaclang.jac.passes.main.sub_node_tab_pass import SubNodeTabPass from jaclang.jac.passes.main.import_pass import ImportPass # noqa: I100 from jaclang.jac.passes.main.sym_tab_build_pass import SymTabBuildPass # noqa: I100 @@ -7,6 +10,8 @@ AstDotGraphPass, AstPrinterPass, ) +from jaclang.jac.passes.tool.fuse_comments_pass import FuseCommentsPass # noqa: I100 +from jaclang.jac.passes.tool.jac_formatter_pass import JacFormatPass # noqa: I100 from jaclang.jac.passes.tool.sym_tab_printer_pass import ( # noqa: I100 SymbolTableDotGraphPass, SymbolTablePrinterPass, @@ -50,15 +55,20 @@ SymbolTableDotGraphPass, ] +format_pass: list[Type[Pass]] = [FuseCommentsPass, JacFormatPass] + __all__ = [ "AstPrinterPass", "AstDotGraphPass", "SymbolTablePrinterPass", "SymbolTableDotGraphPass", + "FuseCommentsPass", + "JacFormatPass", "ast_dot_gen", "full_ast_dot_gen", "ast_print", "full_ast_print", "sym_tab_print", "sym_tab_dot_gen", + "format_pass", ] diff --git a/jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py b/jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py new file mode 100644 index 000000000..0ed24e45a --- /dev/null +++ b/jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py @@ -0,0 +1,23 @@ +"""Test ast build pass module.""" +import ast as ast3 + + +from jaclang.jac.passes.main import PyastGenPass +from jaclang.jac.passes.main.schedules import py_code_gen as without_format +from jaclang.jac.passes.tool import JacFormatPass +from jaclang.jac.transpiler import jac_file_to_pass, jac_str_to_pass +from jaclang.utils.test import TestCase + + +class FuseCommentsPassTests: + """Test pass module.""" + + TargetPass = JacFormatPass + + def setUp(self) -> None: + """Set up test.""" + return super().setUp() + + def test_simple(self) -> None: + """Basic test for pass.""" + code1 = f"with entry #* hi *# {{print('hi');}}" diff --git a/jaclang/jac/transpiler.py b/jaclang/jac/transpiler.py index 44baec219..786cbd258 100644 --- a/jaclang/jac/transpiler.py +++ b/jaclang/jac/transpiler.py @@ -5,12 +5,12 @@ from jaclang.jac.parser import JacParser from jaclang.jac.passes import Pass from jaclang.jac.passes.main import ( - JacFormatPass, PyOutPass, PyastGenPass, pass_schedule, ) -from jaclang.jac.passes.main.schedules import format_pass +from jaclang.jac.passes.tool import JacFormatPass +from jaclang.jac.passes.tool.schedules import format_pass from jaclang.jac.passes.transform import Alert From c433385c5951bca6c4f0bced709929822e3412e2 Mon Sep 17 00:00:00 2001 From: AshishMahendra Date: Thu, 16 Nov 2023 18:41:03 +0000 Subject: [PATCH 2/9] updates for formatter --- jaclang/jac/absyntree.py | 25 ++ jaclang/jac/passes/tool/fuse_comments_pass.py | 48 ++- jaclang/jac/passes/tool/jac_formatter_pass.py | 344 +++--------------- 3 files changed, 103 insertions(+), 314 deletions(-) diff --git a/jaclang/jac/absyntree.py b/jaclang/jac/absyntree.py index 2175e46ab..5f01c8d6b 100644 --- a/jaclang/jac/absyntree.py +++ b/jaclang/jac/absyntree.py @@ -2152,6 +2152,31 @@ class Semi(Token, CodeBlockStmt): class CommentToken(Token): """CommentToken node type for Jac Ast.""" + def __init__( + self, + file_path: str, + name: str, + value: str, + line: int, + col_start: int, + col_end: int, + pos_start: int, + pos_end: int, + kid: Sequence[AstNode], + is_inline: bool = False, + ) -> None: + """Initialize token.""" + self.file_path = file_path + self.name = name + self.value = value + self.line_no = line + self.c_start = col_start + self.c_end = col_end + self.pos_start = pos_start + self.pos_end = pos_end + self.is_inline = is_inline + AstNode.__init__(self, kid=kid) + # ---------------- class JacSource(EmptyToken): diff --git a/jaclang/jac/passes/tool/fuse_comments_pass.py b/jaclang/jac/passes/tool/fuse_comments_pass.py index 90dc5cb53..88ee51d5c 100644 --- a/jaclang/jac/passes/tool/fuse_comments_pass.py +++ b/jaclang/jac/passes/tool/fuse_comments_pass.py @@ -28,29 +28,36 @@ def exit_node(self, node: ast.AstNode) -> None: def after_pass(self) -> None: """Insert comment tokens into all_tokens.""" - marker = 0 + chomp: list[ast.CommentToken] = [*self.comments] new_tokens: list[ast.Token] = [] + if not len(chomp): + return for i in range(len(self.all_tokens)): - new_tokens.append(self.all_tokens[i]) - if i >= len(self.all_tokens) - 1: - break - if marker >= len(self.comments): - new_tokens.extend(self.all_tokens[i + 1 :]) + chomp[0].is_inline = chomp[0].is_inline or ( + self.all_tokens[i].loc.first_line == chomp[0].loc.first_line + ) + # print(chomp[0].is_inline) + if i == len(self.all_tokens) - 1: + if len(chomp): + new_tokens.append(self.all_tokens[i]) + new_tokens += chomp break - elif ( - self.all_tokens[i].loc.first_line - <= self.comments[marker].loc.first_line - or self.all_tokens[i].loc.col_start - <= self.comments[marker].loc.col_start - ) and ( - self.all_tokens[i + 1].loc.last_line - >= self.comments[marker].loc.last_line - or self.all_tokens[i + 1].loc.col_end - >= self.comments[marker].loc.col_end + while (i < len(self.all_tokens) - 1) and ( + ( + self.all_tokens[i].loc.first_line == chomp[0].loc.first_line + and self.all_tokens[i].loc.col_start > chomp[0].loc.col_start + ) + or (self.all_tokens[i].loc.first_line > chomp[0].loc.first_line) ): - new_tokens.append(self.comments[marker]) - marker += 1 - + # print(chomp[0].is_inline) + new_tokens.append(chomp[0]) + chomp = chomp[1:] + if not len(chomp): + new_tokens.extend(self.all_tokens[i + 1 :]) + break + new_tokens.append(self.all_tokens[i]) + if not len(chomp): + break for i in range(len(new_tokens)): if isinstance(new_tokens[i], ast.CommentToken): if i == 0: @@ -59,7 +66,8 @@ def after_pass(self) -> None: new_val = new_tokens[i - 1] if new_val.parent is not None: new_kids = new_val.parent.kid - new_kids.insert(new_kids.index(new_val), new_tokens[i]) + new_kids.insert(new_kids.index(new_val) + 1, new_tokens[i]) new_val.parent.set_kids(new_kids) else: + new_val.print() raise self.ice("Token without parent in AST should be impossible") diff --git a/jaclang/jac/passes/tool/jac_formatter_pass.py b/jaclang/jac/passes/tool/jac_formatter_pass.py index 5ea800b5e..4de2026c6 100644 --- a/jaclang/jac/passes/tool/jac_formatter_pass.py +++ b/jaclang/jac/passes/tool/jac_formatter_pass.py @@ -3,7 +3,7 @@ This is a pass for formatting Jac code. """ -from typing import Any, List, Tuple +from typing import Any # , List, Tuple import jaclang.jac.absyntree as ast from jaclang.jac.constant import Constants as Con @@ -29,126 +29,6 @@ def before_pass(self) -> None: self.preamble = ast.EmptyToken() self.preamble.gen.jac = "" - def get_comments_from_first_column(self) -> List[Tuple[int, str]]: - """Get all comments that belong to column 1.""" - next_line_standalone_comments = [] - for comment in self.comments: - formatted_comment_lines = self.format_comment_to_limit(comment.value) - # for formatted_line in formatted_comment_lines: - next_line_standalone_comments.append( - (comment.line, formatted_comment_lines) - ) - return next_line_standalone_comments - - def format_comment_to_limit(self, comment: str, char_limit: int = 80) -> List[str]: - """Insert Line break for comments.""" - if comment.startswith("#"): - comment = comment[1:].strip() - - words = comment.split() - formatted_lines = [] - current_line = "#" - - for word in words: - if len(current_line + " " + word) <= char_limit: - current_line += " " + word - else: - formatted_lines.append(current_line.strip()) - current_line = "#" + " " + word - - if current_line != "#": - formatted_lines.append(current_line.strip()) - - return "\n".join(formatted_lines) - - def insert_line_breaks(self, line: str, max_len: int = 300) -> str: - """Insert Line break for code.""" - if len(line) <= max_len: - return line - - # Find the last occurrence of ',' or ')' before the max length - break_point = max_len - while break_point > 0: - if line[break_point] in [",", ")", "and"]: - break_point += 1 - break - break_point -= 1 - - # If no comma or parenthesis is found, just split at max_len - if break_point == 0: - break_point = max_len - - # Split the line into two parts at the break_point - part1 = line[:break_point] - part2 = line[break_point:] - # Add indentation to part2 if it starts with "|>" - if part2.strip().startswith("|>"): - part2 = (" " * 4) + part2.lstrip() - # If the second part exceeds max_len, call the function recursively - if len(part2) > max_len: - part2 = self.insert_line_breaks(part2, max_len) - - return part1 + "\n" + part2 - - def emit_comments_for_line( - self, line: int - ) -> Tuple[List[Tuple[int, str]], List[Tuple[int, str]]]: - """Stitch comments associated with the given line.""" - if not line: - return [], [] - - inline_comments = [] - next_line_standalone_comments = [] - - i = 0 - while i < len(self.comments): - comment = self.comments[i] - # Skip comments that start on the 1st column - if comment.column == 1: - i += 1 - continue - # Check if this is a multiline comment - if comment.value.startswith("#*"): - end_line = comment.line - while i < len(self.comments) and not self.comments[i].value.endswith( - "*#" - ): - i += 1 - if i < len(self.comments): - end_line = self.comments[i].line # noqa - # Format the multiline comment and store it with the starting line - formatted_comment_lines = self.format_comment_to_limit(comment.value) - # for formatted_line in formatted_comment_lines: - next_line_standalone_comments.append( - (comment.line, formatted_comment_lines) - ) - - i += 1 # Move past the multiline comment - else: - # Process regular inline or standalone comment - if comment.line == line: - if ( - comment.column < 10 - and comment.value not in self.processed_comments - ): - next_line_standalone_comments.append( - (comment.line, comment.value) - ) - else: - inline_comments.append((comment.line, comment.value)) - elif ( - (comment.line == line + 1 or comment.line == line + 2) - and comment.value not in self.processed_comments - and comment.column < 10 - ): - next_line_standalone_comments.append((comment.line, comment.value)) - i += 1 # Move to the next comment - - return ( - inline_comments, - next_line_standalone_comments, - ) - def enter_node(self, node: ast.AstNode) -> None: """Enter node.""" if node: @@ -215,7 +95,6 @@ def exit_module(self, node: ast.Module) -> None: doc: Token, body: "Elements", """ - standalone_comments = self.get_comments_from_first_column() if node.doc: self.emit_ln(node, node.doc.value) self.emit_ln(node, "") @@ -223,16 +102,6 @@ def exit_module(self, node: ast.Module) -> None: self.emit(node, self.preamble.gen.jac) if node.body: for i in node.body: - for next_line_no, next_line_comment in standalone_comments: - if ( - next_line_no <= i.loc.first_line - and next_line_comment not in self.processed_comments - ): - self.emit_ln(node, next_line_comment) - if next_line_comment.startswith("#*"): - self.emit_ln(node, "") - self.processed_comments.add(next_line_comment) - break self.emit(node, i.gen.jac) self.ir = node self.ir.gen.jac = self.ir.gen.jac.rstrip() @@ -242,70 +111,53 @@ def exit_sub_node_list(self, node: ast.SubNodeList) -> None: items: list[T], """ + count = 0 for stmt in node.kid: - comment_str = "" - ( - inline_comments, - next_line_standalone_comments, - ) = self.emit_comments_for_line(stmt.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) if isinstance(stmt, ast.Token): if stmt.name == "LBRACE": - if comment_str not in self.processed_comments and comment_str != "": - self.emit_ln(node, f" {stmt.value} {comment_str}") - self.processed_comments.add(comment_str) + if ( + count + 1 < len(node.kid) + and isinstance(node.kid[count + 1], ast.CommentToken) + and node.kid[count + 1].is_inline + ): + print(node.kid[count + 1].is_inline) + self.emit(node, f"{stmt.value}") else: self.emit_ln(node, f" {stmt.value}") self.indent_level += 1 - for ( - next_line_no, - next_line_comment, - ) in next_line_standalone_comments: - if ( - next_line_no == node.loc.first_line + 1 - or next_line_no == node.loc.first_line + 2 - ) and next_line_comment not in self.processed_comments: - # Emit the comment on the next line - self.emit_ln(node, next_line_comment) - self.processed_comments.add(next_line_comment) + count += 1 elif stmt.name == "RBRACE": - # self.emit_ln(node, "") self.indent_level -= 1 - if comment_str not in self.processed_comments and comment_str != "": - self.emit_ln(node, f"{stmt.value} {comment_str}") - self.processed_comments.add(comment_str) - self.emit_ln(node, "") - elif isinstance(stmt.parent.parent, (ast.ElseIf, ast.IfStmt)): + if isinstance(stmt.parent.parent, (ast.ElseIf, ast.IfStmt)): self.emit(node, f"{stmt.value}") else: - self.emit_ln(node, f"{stmt.value}") + if ( + count + 1 < len(node.kid) + and isinstance(node.kid[count + 1], ast.CommentToken) + and node.kid[count + 1].is_inline + ): + print(node.kid[count + 1].is_inline) + self.emit(node, f"{stmt.value.lstrip()}") + else: + self.emit_ln(node, f"{stmt.value}") + count += 1 + elif isinstance(stmt, ast.CommentToken): + self.emit_ln(node, f" {stmt.value}") else: self.emit(node, f"{stmt.value}") + count += 1 continue elif isinstance(stmt, ast.Assignment): self.emit(node, f"{stmt.gen.jac}") + count += 1 else: if isinstance(stmt, ast.ExprStmt): - formatted_line = self.insert_line_breaks(stmt.gen.jac) - self.emit(node, f"{formatted_line}") + self.emit(node, f"{stmt.gen.jac}") + count += 1 else: - if comment_str not in self.processed_comments and comment_str != "": - self.emit_ln(node, f"{stmt.gen.jac} {comment_str}") - self.processed_comments.add(comment_str) - else: - self.emit(node, f"{stmt.gen.jac}") - continue - for next_line_no, next_line_comment in next_line_standalone_comments: - if ( - next_line_no == node.loc.first_line + 1 - or next_line_no == node.loc.first_line + 2 - ) and next_line_comment not in self.processed_comments: - # Emit the comment on the next line - self.emit_ln(node, next_line_comment) - self.processed_comments.add(next_line_comment) + self.emit(node, f"{stmt.gen.jac}") + count += 1 + continue def exit_sub_tag(self, node: ast.SubTag) -> None: """Sub objects. @@ -321,14 +173,6 @@ def exit_func_call(self, node: ast.FuncCall) -> None: params: Optional[ParamList], """ comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) if node.params: self.comma_sep_node_list(node.params) self.emit( @@ -338,8 +182,7 @@ def exit_func_call(self, node: ast.FuncCall) -> None: else: self.emit(node, f"{node.target.gen.jac}()") if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + self.emit_ln(node, node.kid[-1].value) def exit_expr_list(self, node: ast.ExprList) -> None: """Sub objects. @@ -500,16 +343,6 @@ def exit_ability(self, node: ast.Ability) -> None: decorators: Optional[SubNodeList[ExprType]] = None, """ comment_str = "" - ( - inline_comments, - next_line_standalone_comments, - ) = self.emit_comments_for_line(node.loc.first_line) - # for comment in standalone_comments: - # self.emit_ln(node, f"{comment}") - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) access_modifier = None if node.doc: self.emit_ln(node, node.doc.gen.jac) @@ -597,32 +430,16 @@ def exit_arch_has(self, node: ast.ArchHas) -> None: vars: "HasVarList", is_frozen: bool, """ - comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) - self.comma_sep_node_list(node.vars) - if node.access: - self.emit( - node, - f"has:{node.access.gen.jac} {node.vars.gen.jac}", # {comment_str}", # noqa - ) - else: - self.emit( - node, - f"has {node.vars.gen.jac}", - ) - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - if comment_str != "": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + + for i in node.kid: + if isinstance(i, ast.SubTag): + for j in i.kid: + self.emit(node, j.gen.jac) + elif isinstance(i, ast.CommentToken): + self.emit(node, f" {i.gen.jac}") else: - self.emit_ln(node, node.kid[-1].value.strip(" ")) + self.emit(node, i.gen.jac) + self.emit_ln(node, "") def exit_arch_ref(self, node: ast.ArchRef) -> None: """Sub objects. @@ -732,14 +549,6 @@ def exit_yield_expr(self, node: ast.YieldExpr) -> None: expr: Optional[ExprType], """ comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) if not node.with_from and node.expr: self.emit(node, f"yield {node.expr.gen.jac}") elif node.expr: @@ -758,12 +567,6 @@ def exit_binary_expr(self, node: ast.BinaryExpr) -> None: op: Token | DisconnectOp | ConnectOp, """ comment_str = "" - (inline_comments, _) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) - if isinstance(node.op, (ast.DisconnectOp, ast.ConnectOp)): self.emit( node, @@ -820,14 +623,12 @@ def exit_has_var(self, node: ast.HasVar) -> None: type_tag: TypeSpec, value: Optional["ExprType"], """ - node.type_tag.gen.jac = node.type_tag.tag.gen.jac - if node.value: - self.emit( - node, - f"{node.name.gen.jac}: {node.type_tag.gen.jac} = {node.value.gen.jac}", # noqa - ) - else: - self.emit(node, f"{node.name.value}: {node.type_tag.gen.jac}") + for i in node.kid: + if isinstance(i, ast.SubTag): + for j in i.kid: + self.emit(node, j.gen.jac) + else: + self.emit(node, f" {i.gen.jac}") def get_mod_index(self, node: ast.AstNode) -> int: """Get module index.""" @@ -1010,14 +811,6 @@ def exit_global_vars(self, node: ast.GlobalVars) -> None: doc: Optional[Constant] = None, """ comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) if node.doc: self.emit_ln(node, node.doc.value) for i in node.kid: @@ -1072,14 +865,6 @@ def exit_assignment(self, node: ast.Assignment) -> None: aug_op: Optional[Token] = None """ comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) self.sep_node_list(node.target, delim="=") self.emit(node, node.target.gen.jac) if node.type_tag: @@ -1424,14 +1209,6 @@ def exit_assert_stmt(self, node: ast.AssertStmt) -> None: error_msg: Optional[ExprType], """ comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) if node.error_msg: self.emit( node, @@ -1450,14 +1227,6 @@ def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None: ctrl: Token, """ comment_str = "" - ( - inline_comments, - next_line_standalone_comments, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) if node.ctrl.name == Tok.KW_SKIP: self.ds_feature_warn() @@ -1473,14 +1242,6 @@ def exit_delete_stmt(self, node: ast.DeleteStmt) -> None: target: ExprType, """ comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) self.emit(node, f"del {node.target.gen.jac}") if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": self.emit_ln(node, node.kid[-1].value + " " + comment_str) @@ -1515,14 +1276,6 @@ def exit_in_for_stmt(self, node: ast.InForStmt) -> None: body: SubNodeList[CodeBlockStmt], """ comment_str = "" - ( - inline_comments, - _, - ) = self.emit_comments_for_line(node.loc.first_line) - if inline_comments: - comment_str = " ; ".join( - comment_value for _, comment_value in inline_comments - ) names = node.target.gen.jac if comment_str not in self.processed_comments and comment_str != "": self.emit( @@ -1796,4 +1549,7 @@ def exit_semi(self, node: ast.Semi) -> None: def exit_comment_token(self, node: ast.CommentToken) -> None: """Sub objects.""" - \ No newline at end of file + if node.is_inline: + self.emit(node, node.value) + else: + self.emit_ln(node, f"{node.value}") From 5b4e3d1e92546e639d4249fa8ff7331a7a15f0ea Mon Sep 17 00:00:00 2001 From: marsninja Date: Thu, 16 Nov 2023 15:13:24 -0500 Subject: [PATCH 3/9] Comments pass a bit more stable --- jaclang/jac/parser.py | 2 +- .../passes/main/tests/test_jac_format_pass.py | 17 ++++++++++++----- jaclang/jac/passes/tool/jac_formatter_pass.py | 19 ------------------- 3 files changed, 13 insertions(+), 25 deletions(-) diff --git a/jaclang/jac/parser.py b/jaclang/jac/parser.py index 9563bf7e1..29d222767 100644 --- a/jaclang/jac/parser.py +++ b/jaclang/jac/parser.py @@ -1080,7 +1080,7 @@ def statement(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt: kid=kid, ) elif isinstance(kid[0], ast.CodeBlockStmt): - kid[0].add_kids_right([kid[1]], pos_update=False) + kid[0].add_kids_right([kid[1]]) return self.nu(kid[0]) else: raise self.ice() diff --git a/jaclang/jac/passes/main/tests/test_jac_format_pass.py b/jaclang/jac/passes/main/tests/test_jac_format_pass.py index aa48d6108..ad67d4de2 100644 --- a/jaclang/jac/passes/main/tests/test_jac_format_pass.py +++ b/jaclang/jac/passes/main/tests/test_jac_format_pass.py @@ -4,8 +4,8 @@ from jaclang.jac.passes.main import PyastGenPass from jaclang.jac.passes.main.schedules import py_code_gen as without_format -from jaclang.jac.passes.tool.schedules import format_pass from jaclang.jac.passes.tool import JacFormatPass +from jaclang.jac.passes.tool.schedules import format_pass from jaclang.jac.transpiler import jac_file_to_pass, jac_str_to_pass from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite @@ -54,10 +54,17 @@ def micro_suite_test(self, filename: str) -> None: for i in range(len(code_gen_pure.ir.gen.py.split("\n"))): if "test_" in code_gen_pure.ir.gen.py.split("\n")[i]: continue - self.assertEqual( - ast3.dump(code_gen_pure.ir.gen.py_ast, indent=2), - ast3.dump(code_gen_jac.ir.gen.py_ast, indent=2), - ) + try: + self.assertEqual( + ast3.dump(code_gen_pure.ir.gen.py_ast, indent=2), + ast3.dump(code_gen_jac.ir.gen.py_ast, indent=2), + ) + except Exception as e: + from jaclang.utils.helpers import add_line_numbers + + print(add_line_numbers(code_gen_pure.ir.source.code)) + print(add_line_numbers(code_gen_format.ir.gen.jac)) + raise e JacFormatPassTests.self_attach_micro_tests() diff --git a/jaclang/jac/passes/tool/jac_formatter_pass.py b/jaclang/jac/passes/tool/jac_formatter_pass.py index 4de2026c6..6d3910433 100644 --- a/jaclang/jac/passes/tool/jac_formatter_pass.py +++ b/jaclang/jac/passes/tool/jac_formatter_pass.py @@ -26,8 +26,6 @@ def before_pass(self) -> None: self.indent_size = 4 self.indent_level = 0 self.debuginfo = {"jac_mods": []} - self.preamble = ast.EmptyToken() - self.preamble.gen.jac = "" def enter_node(self, node: ast.AstNode) -> None: """Enter node.""" @@ -98,8 +96,6 @@ def exit_module(self, node: ast.Module) -> None: if node.doc: self.emit_ln(node, node.doc.value) self.emit_ln(node, "") - if self.preamble: - self.emit(node, self.preamble.gen.jac) if node.body: for i in node.body: self.emit(node, i.gen.jac) @@ -172,7 +168,6 @@ def exit_func_call(self, node: ast.FuncCall) -> None: target: AtomType, params: Optional[ParamList], """ - comment_str = "" if node.params: self.comma_sep_node_list(node.params) self.emit( @@ -430,7 +425,6 @@ def exit_arch_has(self, node: ast.ArchHas) -> None: vars: "HasVarList", is_frozen: bool, """ - for i in node.kid: if isinstance(i, ast.SubTag): for j in i.kid: @@ -661,19 +655,6 @@ def sep_node_list(self, node: ast.SubNodeList, delim: str = " ") -> str: node.gen.jac = f"{delim}".join([i.gen.jac for i in node.items]) return node.gen.jac - def needs_jac_import(self) -> None: - """Check if import is needed.""" - self.emit_ln_unique( - self.preamble, "from jaclang import jac_import as __jac_import__" - ) - - def needs_enum(self) -> None: - """Check if enum is needed.""" - self.emit_ln_unique( - self.preamble, - "from enum import Enum as __jac_Enum__, auto as __jac_auto__", - ) - def ds_feature_warn(self) -> None: """Warn about feature.""" self.warning("Data spatial features not supported in bootstrap Jac.") From 1a1a7a565a0bb0d6bc5163d70b6d571f6c3cda2e Mon Sep 17 00:00:00 2001 From: marsninja Date: Thu, 16 Nov 2023 15:26:10 -0500 Subject: [PATCH 4/9] hrm, maybe big cleanup needed --- jaclang/jac/passes/tool/jac_formatter_pass.py | 137 +++++++----------- 1 file changed, 54 insertions(+), 83 deletions(-) diff --git a/jaclang/jac/passes/tool/jac_formatter_pass.py b/jaclang/jac/passes/tool/jac_formatter_pass.py index 6d3910433..cd40b4d85 100644 --- a/jaclang/jac/passes/tool/jac_formatter_pass.py +++ b/jaclang/jac/passes/tool/jac_formatter_pass.py @@ -2,9 +2,6 @@ This is a pass for formatting Jac code. """ - -from typing import Any # , List, Tuple - import jaclang.jac.absyntree as ast from jaclang.jac.constant import Constants as Con from jaclang.jac.constant import Tokens as Tok @@ -14,24 +11,12 @@ class JacFormatPass(Pass): """JacFormat Pass format Jac code.""" - def __init__(self, *args: Any, **kwargs: Any) -> None: # noqa # noqa - """Initialize Formatter.""" - self.comments = [] - self.processed_comments = set() - - super().__init__(*args, **kwargs) - def before_pass(self) -> None: """Initialize pass.""" + self.comments: list[ast.CommentToken] = [] + self.processed_comments = set() self.indent_size = 4 self.indent_level = 0 - self.debuginfo = {"jac_mods": []} - - def enter_node(self, node: ast.AstNode) -> None: - """Enter node.""" - if node: - node.gen.jac = "" - return Pass.enter_node(self, node) def indent_str(self) -> str: """Return string for indent.""" @@ -48,13 +33,58 @@ def emit_ln(self, node: ast.AstNode, s: str) -> None: self.emit(node, s.strip().strip("\n")) self.emit(node, "\n") - def emit_ln_unique(self, node: ast.AstNode, s: str) -> None: - """Emit code to node.""" - if s not in node.gen.jac: - ilev = self.indent_level - self.indent_level = 0 - self.emit_ln(node, s) - self.indent_level = ilev + def enter_module(self, node: ast.Module) -> None: + """Sub objects. + + name: str, + source: JacSource, + doc: Optional[String], + body: Sequence[ElementStmt], + is_imported: bool, + """ + self.comments = node.source.comments + + def exit_module(self, node: ast.Module) -> None: + """Sub objects. + + name: str, + source: JacSource, + doc: Optional[String], + body: Sequence[ElementStmt], + is_imported: bool, + """ + if node.doc: + self.emit_ln(node, node.doc.value) + self.emit_ln(node, "") + if node.body: + for i in node.body: + self.emit(node, i.gen.jac) + self.ir = node + self.ir.gen.jac = self.ir.gen.jac.rstrip() + + def exit_global_vars(self, node: ast.GlobalVars) -> None: + """Sub objects. + + access: Optional[SubTag[Token]], + assignments: SubNodeList[Assignment], + is_frozen: bool, + doc: Optional[String] = None, + """ + comment_str = "" + if node.doc: + self.emit_ln(node, node.doc.value) + for i in node.kid: + if isinstance(i, ast.String): + continue + elif isinstance(i, ast.Token): + if i.name == "SEMI": + self.emit_ln(node, i.value + " " + comment_str) + self.processed_comments.add(comment_str) + else: + self.emit(node, i.value + " ") + elif isinstance(i, ast.SubNodeList): + self.emit(node, node.assignments.gen.jac) + self.emit_ln(node, "") def exit_module_code(self, node: ast.ModuleCode) -> None: """Sub objects. @@ -76,32 +106,6 @@ def exit_module_code(self, node: ast.ModuleCode) -> None: if node.body: self.emit(node, node.body.gen.jac) - def enter_module(self, node: ast.Module) -> None: - """Sub objects. - - name: Optional[SubTag[Name]], - body: SubNodeList[CodeBlockStmt], - doc: Optional[Constant] = None, - """ - if node.source.comments: - self.comments = node.source.comments - - def exit_module(self, node: ast.Module) -> None: - """Sub objects. - - name: str, - doc: Token, - body: "Elements", - """ - if node.doc: - self.emit_ln(node, node.doc.value) - self.emit_ln(node, "") - if node.body: - for i in node.body: - self.emit(node, i.gen.jac) - self.ir = node - self.ir.gen.jac = self.ir.gen.jac.rstrip() - def exit_sub_node_list(self, node: ast.SubNodeList) -> None: """Sub objects. @@ -624,15 +628,6 @@ def exit_has_var(self, node: ast.HasVar) -> None: else: self.emit(node, f" {i.gen.jac}") - def get_mod_index(self, node: ast.AstNode) -> int: - """Get module index.""" - path = node.loc.mod_path - if not path: - return -1 - if path not in self.debuginfo["jac_mods"]: - self.debuginfo["jac_mods"].append(path) - return self.debuginfo["jac_mods"].index(path) - def comma_sep_node_list(self, node: ast.SubNodeList) -> str: """Render comma separated node list.""" node.gen.jac = ", ".join([i.gen.jac for i in node.items]) @@ -783,30 +778,6 @@ def exit_with_stmt(self, node: ast.WithStmt) -> None: if node.body.gen.jac: self.emit(node, node.body.gen.jac) - def exit_global_vars(self, node: ast.GlobalVars) -> None: - """Sub objects. - - access: Optional[SubTag[Token]], - assignments: SubNodeList[Assignment], - is_frozen: bool, - doc: Optional[Constant] = None, - """ - comment_str = "" - if node.doc: - self.emit_ln(node, node.doc.value) - for i in node.kid: - if isinstance(i, ast.String): - continue - elif isinstance(i, ast.Token): - if i.name == "SEMI": - self.emit_ln(node, i.value + " " + comment_str) - self.processed_comments.add(comment_str) - else: - self.emit(node, i.value + " ") - elif isinstance(i, ast.SubNodeList): - self.emit(node, node.assignments.gen.jac) - self.emit_ln(node, "") - def exit_module_item(self, node: ast.ModuleItem) -> None: """Sub objects. From 7f32d9c35f8a291d1b91535e0b42700ce9e19994 Mon Sep 17 00:00:00 2001 From: marsninja Date: Thu, 16 Nov 2023 16:29:01 -0500 Subject: [PATCH 5/9] Need to understand the comment strategy --- jaclang/jac/passes/tool/jac_formatter_pass.py | 63 ++++++++----------- 1 file changed, 26 insertions(+), 37 deletions(-) diff --git a/jaclang/jac/passes/tool/jac_formatter_pass.py b/jaclang/jac/passes/tool/jac_formatter_pass.py index cd40b4d85..4dc4fbd7a 100644 --- a/jaclang/jac/passes/tool/jac_formatter_pass.py +++ b/jaclang/jac/passes/tool/jac_formatter_pass.py @@ -33,6 +33,28 @@ def emit_ln(self, node: ast.AstNode, s: str) -> None: self.emit(node, s.strip().strip("\n")) self.emit(node, "\n") + def comma_sep_node_list(self, node: ast.SubNodeList) -> str: + """Render comma separated node list.""" + node.gen.jac = ", ".join([i.gen.jac for i in node.items]) + return node.gen.jac + + def dot_sep_node_list(self, node: ast.SubNodeList) -> str: + """Render dot separated node list.""" + node.gen.jac = ".".join([i.gen.jac for i in node.items]) + return node.gen.jac + + def nl_sep_node_list(self, node: ast.SubNodeList) -> str: + """Render newline separated node list.""" + node.gen.jac = "" + for i in node.items: + node.gen.jac += f"{i.gen.jac}\n" + return node.gen.jac + + def sep_node_list(self, node: ast.SubNodeList, delim: str = " ") -> str: + """Render newline separated node list.""" + node.gen.jac = f"{delim}".join([i.gen.jac for i in node.items]) + return node.gen.jac + def enter_module(self, node: ast.Module) -> None: """Sub objects. @@ -56,11 +78,9 @@ def exit_module(self, node: ast.Module) -> None: if node.doc: self.emit_ln(node, node.doc.value) self.emit_ln(node, "") - if node.body: - for i in node.body: - self.emit(node, i.gen.jac) - self.ir = node - self.ir.gen.jac = self.ir.gen.jac.rstrip() + for i in node.body: + self.emit_ln(node, i.gen.jac) + self.emit_ln(node, "") def exit_global_vars(self, node: ast.GlobalVars) -> None: """Sub objects. @@ -628,32 +648,6 @@ def exit_has_var(self, node: ast.HasVar) -> None: else: self.emit(node, f" {i.gen.jac}") - def comma_sep_node_list(self, node: ast.SubNodeList) -> str: - """Render comma separated node list.""" - node.gen.jac = ", ".join([i.gen.jac for i in node.items]) - return node.gen.jac - - def dot_sep_node_list(self, node: ast.SubNodeList) -> str: - """Render dot separated node list.""" - node.gen.jac = ".".join([i.gen.jac for i in node.items]) - return node.gen.jac - - def nl_sep_node_list(self, node: ast.SubNodeList) -> str: - """Render newline separated node list.""" - node.gen.jac = "" - for i in node.items: - node.gen.jac += f"{i.gen.jac}\n" - return node.gen.jac - - def sep_node_list(self, node: ast.SubNodeList, delim: str = " ") -> str: - """Render newline separated node list.""" - node.gen.jac = f"{delim}".join([i.gen.jac for i in node.items]) - return node.gen.jac - - def ds_feature_warn(self) -> None: - """Warn about feature.""" - self.warning("Data spatial features not supported in bootstrap Jac.") - def exit_if_stmt(self, node: ast.IfStmt) -> None: """Sub objects. @@ -1179,11 +1173,7 @@ def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None: ctrl: Token, """ comment_str = "" - - if node.ctrl.name == Tok.KW_SKIP: - self.ds_feature_warn() - else: - self.emit(node, node.ctrl.value) + self.emit(node, node.ctrl.value) if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": self.emit_ln(node, node.kid[-1].value + " " + comment_str) self.processed_comments.add(comment_str) @@ -1277,7 +1267,6 @@ def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: type_ctx: TypeList, body: CodeBlock, """ - self.ds_feature_warn() def exit_match_stmt(self, node: ast.MatchStmt) -> None: """Sub objects. From 0280eb6aff01ffee22417b0b798ac483d7d4a74a Mon Sep 17 00:00:00 2001 From: marsninja Date: Fri, 17 Nov 2023 11:14:33 -0500 Subject: [PATCH 6/9] Two tweaks --- jaclang/jac/passes/main/pyast_gen_pass.py | 12 ++++++++++++ jaclang/jac/passes/main/sym_tab_build_pass.py | 4 ++++ 2 files changed, 16 insertions(+) diff --git a/jaclang/jac/passes/main/pyast_gen_pass.py b/jaclang/jac/passes/main/pyast_gen_pass.py index 5bafc210e..ef6eef794 100644 --- a/jaclang/jac/passes/main/pyast_gen_pass.py +++ b/jaclang/jac/passes/main/pyast_gen_pass.py @@ -2333,3 +2333,15 @@ def exit_semi(self, node: ast.Semi) -> None: pos_start: int, pos_end: int, """ + + def exit_comment_token(self, node: ast.CommentToken) -> None: + """Sub objects. + + file_path: str, + name: str, + value: str, + col_start: int, + col_end: int, + pos_start: int, + pos_end: int, + """ diff --git a/jaclang/jac/passes/main/sym_tab_build_pass.py b/jaclang/jac/passes/main/sym_tab_build_pass.py index 8f09301b1..658ba1bd6 100644 --- a/jaclang/jac/passes/main/sym_tab_build_pass.py +++ b/jaclang/jac/passes/main/sym_tab_build_pass.py @@ -1366,3 +1366,7 @@ def enter_builtin_type(self, node: ast.BuiltinType) -> None: def enter_semi(self, node: ast.Semi) -> None: """Sub objects.""" self.sync_node_to_scope(node) + + def enter_comment_token(self, node: ast.CommentToken) -> None: + """Sub objects.""" + self.sync_node_to_scope(node) From ad16ed7c5c87bf2f25c6c1ccf5bf6982d981d708 Mon Sep 17 00:00:00 2001 From: AshishMahendra Date: Fri, 17 Nov 2023 16:37:25 +0000 Subject: [PATCH 7/9] fix for the format issue, added missing structures --- jaclang/jac/passes/tool/jac_formatter_pass.py | 403 ++++++++++-------- 1 file changed, 214 insertions(+), 189 deletions(-) diff --git a/jaclang/jac/passes/tool/jac_formatter_pass.py b/jaclang/jac/passes/tool/jac_formatter_pass.py index 4dc4fbd7a..e65943d3e 100644 --- a/jaclang/jac/passes/tool/jac_formatter_pass.py +++ b/jaclang/jac/passes/tool/jac_formatter_pass.py @@ -14,9 +14,9 @@ class JacFormatPass(Pass): def before_pass(self) -> None: """Initialize pass.""" self.comments: list[ast.CommentToken] = [] - self.processed_comments = set() self.indent_size = 4 self.indent_level = 0 + self.prev_brac = False def indent_str(self) -> str: """Return string for indent.""" @@ -90,7 +90,6 @@ def exit_global_vars(self, node: ast.GlobalVars) -> None: is_frozen: bool, doc: Optional[String] = None, """ - comment_str = "" if node.doc: self.emit_ln(node, node.doc.value) for i in node.kid: @@ -98,8 +97,7 @@ def exit_global_vars(self, node: ast.GlobalVars) -> None: continue elif isinstance(i, ast.Token): if i.name == "SEMI": - self.emit_ln(node, i.value + " " + comment_str) - self.processed_comments.add(comment_str) + self.emit_ln(node, i.value + " ") else: self.emit(node, i.value + " ") elif isinstance(i, ast.SubNodeList): @@ -121,8 +119,8 @@ def exit_module_code(self, node: ast.ModuleCode) -> None: if isinstance(i, ast.Token): self.emit(node, i.value.strip("") + " ") elif isinstance(i, ast.SubTag): - self.emit(node, ":" + i.gen.jac.strip("") + " ") - + for j in i.kid: + self.emit(node, j.gen.jac) if node.body: self.emit(node, node.body.gen.jac) @@ -140,7 +138,6 @@ def exit_sub_node_list(self, node: ast.SubNodeList) -> None: and isinstance(node.kid[count + 1], ast.CommentToken) and node.kid[count + 1].is_inline ): - print(node.kid[count + 1].is_inline) self.emit(node, f"{stmt.value}") else: self.emit_ln(node, f" {stmt.value}") @@ -148,18 +145,24 @@ def exit_sub_node_list(self, node: ast.SubNodeList) -> None: count += 1 elif stmt.name == "RBRACE": self.indent_level -= 1 - if isinstance(stmt.parent.parent, (ast.ElseIf, ast.IfStmt)): + if ( + isinstance(stmt.parent.parent, (ast.ElseIf, ast.IfStmt)) + and not self.prev_brac + ): self.emit(node, f"{stmt.value}") + self.prev_brac = True + else: if ( count + 1 < len(node.kid) and isinstance(node.kid[count + 1], ast.CommentToken) and node.kid[count + 1].is_inline ): - print(node.kid[count + 1].is_inline) self.emit(node, f"{stmt.value.lstrip()}") + self.prev_brac = True else: self.emit_ln(node, f"{stmt.value}") + self.prev_brac = False count += 1 elif isinstance(stmt, ast.CommentToken): self.emit_ln(node, f" {stmt.value}") @@ -184,7 +187,8 @@ def exit_sub_tag(self, node: ast.SubTag) -> None: tag: T, """ - self.emit(node, node.tag.gen.jac) + for i in node.kid: + self.emit(node, i.gen.jac) def exit_func_call(self, node: ast.FuncCall) -> None: """Sub objects. @@ -192,16 +196,17 @@ def exit_func_call(self, node: ast.FuncCall) -> None: target: AtomType, params: Optional[ParamList], """ - if node.params: - self.comma_sep_node_list(node.params) - self.emit( - node, - f"{node.target.gen.jac}({node.params.gen.jac})", - ) - else: - self.emit(node, f"{node.target.gen.jac}()") - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value) + # node.print() + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + else: + self.emit(node, i.gen.jac) + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_expr_list(self, node: ast.ExprList) -> None: """Sub objects. @@ -271,24 +276,16 @@ def exit_ability_def(self, node: ast.AbilityDef) -> None: doc: Optional[Constant] = None, decorators: Optional[SubNodeList[ExprType]] = None, """ - if node.doc: - self.emit_ln(node, node.doc.gen.jac) - if isinstance(node.signature, ast.EventSignature): - # need to find a example and implement - self.warning("This Event Defination is not available currently") - return - else: - fun_def = "" - for arch in node.target.archs: - fun_def += arch.gen.jac - if node.signature.gen.jac.strip(): - self.emit(node, f"{fun_def} {node.signature.gen.jac} ") + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) else: - self.emit(node, f"{fun_def} ") - - if node.body: - self.emit(node, node.body.gen.jac) - self.emit_ln(node, "") + self.emit(node, i.gen.jac) + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_event_signature(self, node: ast.EventSignature) -> None: """Sub objects. @@ -297,11 +294,23 @@ def exit_event_signature(self, node: ast.EventSignature) -> None: arch_tag_info: Optional["TypeList | TypeSpec"], return_type: Optional["TypeSpec"], """ - event_value = node.event.value if node.event else None - if node.arch_tag_info: - self.emit(node, f"{node.arch_tag_info.gen.jac} {event_value}") - else: - self.emit(node, f"{event_value}") + start = True + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False + else: + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_import(self, node: ast.Import) -> None: """Sub objects. @@ -361,59 +370,28 @@ def exit_ability(self, node: ast.Ability) -> None: doc: Optional[Constant] = None, decorators: Optional[SubNodeList[ExprType]] = None, """ - comment_str = "" - access_modifier = None if node.doc: self.emit_ln(node, node.doc.gen.jac) - if node.access: - access_modifier = node.access.gen.jac - if node.decorators: - self.emit_ln(node, node.decorators.gen.jac) - if isinstance(node.signature, (ast.FuncSignature, ast.EventSignature)): - if isinstance(node.signature, ast.EventSignature): - can_name = ( - node.name_ref.value - if isinstance(node.name_ref, ast.Name) - else node.name_ref.sym_name - ) - if node.body: - self.emit( - node, - f"can {can_name} with {node.signature.gen.jac}", # noqa - ) - - self.emit(node, node.body.gen.jac) - - else: - self.emit( - node, - f"can {can_name} with {node.signature.gen.jac}", # noqa - ) - elif isinstance(node.signature, ast.FuncSignature): - if isinstance(node.name_ref, ast.SpecialVarRef): - if access_modifier: - fun_signature = f"can:{access_modifier} {node.name_ref.var.value}{node.signature.gen.jac}" # noqa - else: - fun_signature = f"can {node.name_ref.var.value}{node.signature.gen.jac}" # noqa + start = True + for i in node.kid: + print(i) + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") else: - func_name = node.name_ref.sym_name - if access_modifier: - fun_signature = f"can:{access_modifier} {func_name}{node.signature.gen.jac}" # noqa - else: - fun_signature = ( - f"can {func_name}{node.signature.gen.jac}" # noqa - ) - if node.body: - self.emit(node, f"{fun_signature}") - self.emit(node, node.body.gen.jac) + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + elif isinstance(i, ast.SubNodeList) and i.gen.jac.startswith("@"): + self.emit_ln(node, i.gen.jac) + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False else: - if node.is_abstract: - self.emit(node, f"{fun_signature} abstract") - else: - self.emit(node, f"{fun_signature}") - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_func_signature(self, node: ast.FuncSignature) -> None: """Sub objects. @@ -421,24 +399,8 @@ def exit_func_signature(self, node: ast.FuncSignature) -> None: params: Optional[SubNodeList[ParamVar]], return_type: Optional[SubNodeList[TypeSpec]], """ - empty_token = False - return_sub_tag = None for kid in node.kid: - if isinstance(kid, ast.EmptyToken): - empty_token = True - if isinstance(kid, ast.SubTag): - return_sub_tag = kid.gen.jac - if node.params: - self.comma_sep_node_list(node.params) - self.emit(node, f"({node.params.gen.jac})") - if node.return_type: - self.emit(node, f" -> {node.return_type.gen.jac} ") - elif empty_token: - self.emit(node, " ") - elif return_sub_tag: - self.emit(node, f" -> {return_sub_tag}") - else: - self.emit(node, " -> None") + self.emit(node, f"{kid.gen.jac}") def exit_arch_has(self, node: ast.ArchHas) -> None: """Sub objects. @@ -464,10 +426,16 @@ def exit_arch_ref(self, node: ast.ArchRef) -> None: archs: list[ArchRef], """ - if isinstance(node.name_ref, ast.SpecialVarRef): - self.emit(node, f"{node.arch.value}{node.name_ref.var.gen.jac}") - else: - self.emit(node, f"{node.arch.value}{node.name_ref.sym_name}") + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + else: + self.emit(node, i.gen.jac) + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_param_var(self, node: ast.ParamVar) -> None: """Sub objects. @@ -477,15 +445,8 @@ def exit_param_var(self, node: ast.ParamVar) -> None: type_tag: SubTag[SubNodeList[TypeSpec]], value: Optional[ExprType], """ - if node.unpack: - self.emit(node, f"{node.unpack.value}") - if node.value: - self.emit( - node, - f"{node.name.value}: {node.type_tag.gen.jac} = {node.value.gen.jac}", # noqa - ) - else: - self.emit(node, f"{node.name.value}: {node.type_tag.gen.jac}") + for i in node.kid: + self.emit(node, i.gen.jac) def exit_enum(self, node: ast.Enum) -> None: """Sub objects. @@ -566,7 +527,6 @@ def exit_yield_expr(self, node: ast.YieldExpr) -> None: expr: Optional[ExprType], """ - comment_str = "" if not node.with_from and node.expr: self.emit(node, f"yield {node.expr.gen.jac}") elif node.expr: @@ -574,8 +534,7 @@ def exit_yield_expr(self, node: ast.YieldExpr) -> None: else: self.emit(node, "yield") if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + self.emit_ln(node, node.kid[-1].value + " ") def exit_binary_expr(self, node: ast.BinaryExpr) -> None: """Sub objects. @@ -584,7 +543,6 @@ def exit_binary_expr(self, node: ast.BinaryExpr) -> None: right: ExprType, op: Token | DisconnectOp | ConnectOp, """ - comment_str = "" if isinstance(node.op, (ast.DisconnectOp, ast.ConnectOp)): self.emit( node, @@ -630,9 +588,8 @@ def exit_binary_expr(self, node: ast.BinaryExpr) -> None: self.error( f"Binary operator {node.op.value} not supported in bootstrap Jac" ) - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, node.kid[-1].value) def exit_has_var(self, node: ast.HasVar) -> None: """Sub objects. @@ -656,12 +613,23 @@ def exit_if_stmt(self, node: ast.IfStmt) -> None: elseifs: Optional[ElseIfs], else_body: Optional[ElseStmt], """ - self.emit(node, f"if {node.condition.gen.jac} ") - self.emit(node, node.body.gen.jac) - - if node.else_body: - self.emit(node, node.else_body.gen.jac) - self.emit_ln(node, "") + start = True + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False + else: + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_else_if(self, node: ast.ElseIf) -> None: """Sub objects. @@ -693,9 +661,23 @@ def exit_expr_stmt(self, node: ast.ExprStmt) -> None: expr: ExprType, """ - self.emit(node, node.expr.gen.jac) - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value) + start = True + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False + else: + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_iter_for_stmt(self, node: ast.IterForStmt) -> None: """Sub objects. @@ -810,21 +792,18 @@ def exit_assignment(self, node: ast.Assignment) -> None: mutable: bool = True, aug_op: Optional[Token] = None """ - comment_str = "" - self.sep_node_list(node.target, delim="=") - self.emit(node, node.target.gen.jac) - if node.type_tag: - self.emit(node, f": {node.type_tag.tag.gen.jac}") - if node.aug_op: - self.emit(node, f" {node.aug_op.value} ") - else: - self.emit(node, " = ") - - if node.value: - self.emit(node, f"{node.value.gen.jac}") - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit_ln(node, i.gen.jac) + else: + self.emit(node, i.gen.jac) + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_architype(self, node: ast.Architype) -> None: """Sub objects. @@ -957,10 +936,10 @@ def exit_index_slice(self, node: ast.IndexSlice) -> None: self.emit( node, f"[{node.start.gen.jac if node.start else ''}:" - f"{node.stop.gen.jac if node.stop else ''}]", + f"{node.stop.gen.jac if node.stop else ''}] ", ) elif node.start: - self.emit(node, f"[{node.start.gen.jac}]") + self.emit(node, f"[{node.start.gen.jac}] ") else: self.ice("Something went horribly wrong.") @@ -1143,10 +1122,23 @@ def exit_return_stmt(self, node: ast.ReturnStmt) -> None: expr: Optional[ExprType], """ - if node.expr: - self.emit_ln(node, f"return {node.expr.gen.jac};") - else: - self.emit_ln(node, "return;") + start = True + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False + else: + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_assert_stmt(self, node: ast.AssertStmt) -> None: """Sub objects. @@ -1154,7 +1146,6 @@ def exit_assert_stmt(self, node: ast.AssertStmt) -> None: condition: ExprType, error_msg: Optional[ExprType], """ - comment_str = "" if node.error_msg: self.emit( node, @@ -1164,40 +1155,76 @@ def exit_assert_stmt(self, node: ast.AssertStmt) -> None: self.emit(node, f"assert {node.condition.gen.jac}") if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + self.emit_ln(node, node.kid[-1].value + " ") def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None: """Sub objects. ctrl: Token, """ - comment_str = "" - self.emit(node, node.ctrl.value) - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + start = True + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False + else: + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_delete_stmt(self, node: ast.DeleteStmt) -> None: """Sub objects. target: ExprType, """ - comment_str = "" - self.emit(node, f"del {node.target.gen.jac}") - if isinstance(node.kid[-1], ast.Token) and node.kid[-1].name == "SEMI": - self.emit_ln(node, node.kid[-1].value + " " + comment_str) - self.processed_comments.add(comment_str) + start = True + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False + else: + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_report_stmt(self, node: ast.ReportStmt) -> None: """Sub objects. expr: ExprType, """ - if node.expr: - self.emit_ln(node, f"report {node.expr.gen.jac};") - else: - self.emit_ln(node, "report;") + start = True + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + elif isinstance(i, ast.Semi): + self.emit(node, f"{i.gen.jac}") + else: + if start: + self.emit(node, f"{i.gen.jac}") + start = False + else: + self.emit(node, f" {i.gen.jac}") + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_expr_as_item(self, node: ast.ExprAsItem) -> None: """Sub objects. @@ -1217,16 +1244,8 @@ def exit_in_for_stmt(self, node: ast.InForStmt) -> None: collection: ExprType, body: SubNodeList[CodeBlockStmt], """ - comment_str = "" names = node.target.gen.jac - if comment_str not in self.processed_comments and comment_str != "": - self.emit( - node, - f"for {names} in {node.collection.gen.jac} {comment_str}", - ) - self.processed_comments.add(comment_str) - else: - self.emit(node, f"for {names} in {node.collection.gen.jac} ") + self.emit(node, f"for {names} in {node.collection.gen.jac} ") self.emit(node, node.body.gen.jac) def exit_test(self, node: ast.Test) -> None: @@ -1259,7 +1278,16 @@ def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None: archs: list[ArchRef], """ - self.emit(node, ".".join([i.gen.jac for i in node.archs])) + for i in node.kid: + if isinstance(i, ast.CommentToken): + if i.is_inline: + self.emit(node, f" {i.gen.jac}") + else: + self.emit_ln(node, i.gen.jac) + else: + self.emit(node, i.gen.jac) + if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)): + self.emit_ln(node, "") def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None: """Sub objects. @@ -1490,7 +1518,4 @@ def exit_semi(self, node: ast.Semi) -> None: def exit_comment_token(self, node: ast.CommentToken) -> None: """Sub objects.""" - if node.is_inline: - self.emit(node, node.value) - else: - self.emit_ln(node, f"{node.value}") + self.emit(node, f"{node.value}") From fd337892a4e63aa893d3e36acbd8d0405062a318 Mon Sep 17 00:00:00 2001 From: marsninja Date: Fri, 17 Nov 2023 17:30:03 -0500 Subject: [PATCH 8/9] Tweak --- jaclang/jac/passes/tool/jac_formatter_pass.py | 1 - 1 file changed, 1 deletion(-) diff --git a/jaclang/jac/passes/tool/jac_formatter_pass.py b/jaclang/jac/passes/tool/jac_formatter_pass.py index e65943d3e..c0c980627 100644 --- a/jaclang/jac/passes/tool/jac_formatter_pass.py +++ b/jaclang/jac/passes/tool/jac_formatter_pass.py @@ -374,7 +374,6 @@ def exit_ability(self, node: ast.Ability) -> None: self.emit_ln(node, node.doc.gen.jac) start = True for i in node.kid: - print(i) if isinstance(i, ast.CommentToken): if i.is_inline: self.emit(node, f" {i.gen.jac}") From 788c6c8997c6735d9700255c4fd59f328e795bdd Mon Sep 17 00:00:00 2001 From: marsninja Date: Fri, 17 Nov 2023 17:34:05 -0500 Subject: [PATCH 9/9] Lint fixed --- jaclang/jac/absyntree.py | 1 - jaclang/jac/passes/tool/fuse_comments_pass.py | 7 +------ jaclang/jac/passes/tool/schedules.py | 3 ++- jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py | 9 +-------- 4 files changed, 4 insertions(+), 16 deletions(-) diff --git a/jaclang/jac/absyntree.py b/jaclang/jac/absyntree.py index 279c6fd3b..b98204edf 100644 --- a/jaclang/jac/absyntree.py +++ b/jaclang/jac/absyntree.py @@ -5,7 +5,6 @@ import pprint from typing import Any, Callable, Generic, Optional, Sequence, Type, TypeVar -from jaclang.jac import jac_lark as jl from jaclang.jac.codeloc import CodeGenTarget, CodeLocInfo from jaclang.jac.constant import Constants as Con, EdgeDir from jaclang.jac.constant import Tokens as Tok diff --git a/jaclang/jac/passes/tool/fuse_comments_pass.py b/jaclang/jac/passes/tool/fuse_comments_pass.py index 88ee51d5c..3cba9d55c 100644 --- a/jaclang/jac/passes/tool/fuse_comments_pass.py +++ b/jaclang/jac/passes/tool/fuse_comments_pass.py @@ -3,11 +3,7 @@ This is a pass for formatting Jac code. """ -from typing import Any, List, Tuple - import jaclang.jac.absyntree as ast -from jaclang.jac.constant import Constants as Con -from jaclang.jac.constant import Tokens as Tok from jaclang.jac.passes import Pass @@ -15,6 +11,7 @@ class FuseCommentsPass(Pass): """JacFormat Pass format Jac code.""" def before_pass(self) -> None: + """Before pass.""" self.all_tokens: list[ast.Token] = [] self.comments: list[ast.Token] = ( self.ir.source.comments if isinstance(self.ir, ast.Module) else [] @@ -36,7 +33,6 @@ def after_pass(self) -> None: chomp[0].is_inline = chomp[0].is_inline or ( self.all_tokens[i].loc.first_line == chomp[0].loc.first_line ) - # print(chomp[0].is_inline) if i == len(self.all_tokens) - 1: if len(chomp): new_tokens.append(self.all_tokens[i]) @@ -49,7 +45,6 @@ def after_pass(self) -> None: ) or (self.all_tokens[i].loc.first_line > chomp[0].loc.first_line) ): - # print(chomp[0].is_inline) new_tokens.append(chomp[0]) chomp = chomp[1:] if not len(chomp): diff --git a/jaclang/jac/passes/tool/schedules.py b/jaclang/jac/passes/tool/schedules.py index 2231047b7..d25d0b0ee 100644 --- a/jaclang/jac/passes/tool/schedules.py +++ b/jaclang/jac/passes/tool/schedules.py @@ -2,7 +2,8 @@ from typing import Type from ..ir_pass import Pass -from jaclang.jac.passes.main.sub_node_tab_pass import SubNodeTabPass + +from jaclang.jac.passes.main.sub_node_tab_pass import SubNodeTabPass # noqa: I100 from jaclang.jac.passes.main.import_pass import ImportPass # noqa: I100 from jaclang.jac.passes.main.sym_tab_build_pass import SymTabBuildPass # noqa: I100 from jaclang.jac.passes.main.def_impl_match_pass import DeclDefMatchPass # noqa: I100 diff --git a/jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py b/jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py index 0ed24e45a..bb0dced7b 100644 --- a/jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py +++ b/jaclang/jac/passes/tool/tests/test_fuse_comments_pass.py @@ -1,12 +1,5 @@ """Test ast build pass module.""" -import ast as ast3 - - -from jaclang.jac.passes.main import PyastGenPass -from jaclang.jac.passes.main.schedules import py_code_gen as without_format from jaclang.jac.passes.tool import JacFormatPass -from jaclang.jac.transpiler import jac_file_to_pass, jac_str_to_pass -from jaclang.utils.test import TestCase class FuseCommentsPassTests: @@ -20,4 +13,4 @@ def setUp(self) -> None: def test_simple(self) -> None: """Basic test for pass.""" - code1 = f"with entry #* hi *# {{print('hi');}}" + # code1 = f"with entry #* hi *# {{print('hi');}}"