jaclang 0.8.6__py3-none-any.whl → 0.8.8__py3-none-any.whl

jaclang/compiler/passes/tool/doc_ir_gen_pass.py

@@ -220,6 +220,8 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif not in_body and isinstance(i, uni.Token) and i.name == Tok.DECOR_OP:
+                parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -257,6 +259,8 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif not in_body and isinstance(i, uni.Token) and i.name == Tok.DECOR_OP:
+                parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -275,8 +279,17 @@ class DocIRGenPass(UniPass):
             elif isinstance(i, uni.Token) and i.name == Tok.RPAREN and node.params:
                 in_params = False
                 has_parens = True
+                if isinstance(indent_parts[-1], doc.Line):
+                    indent_parts.pop()
                 parts.append(
-                    self.indent(self.concat([self.tight_line(), *indent_parts]))
+                    self.indent(
+                        self.concat(
+                            [
+                                self.tight_line(),
+                                self.group(self.concat([*indent_parts])),
+                            ]
+                        )
+                    )
                 )
                 parts.append(self.tight_line())
                 parts.append(i.gen.doc_ir)
@@ -346,14 +359,14 @@ class DocIRGenPass(UniPass):
                     lhs_parts.append(self.space())
 
         if eq_tok is not None:
-            rhs_concat = self.concat(rhs_parts)
+            rhs_concat = self.group(self.concat(rhs_parts))
             node.gen.doc_ir = self.group(
                 self.concat(
                     [
                         *lhs_parts,
                         self.space(),
                         eq_tok,
-                        self.indent(self.concat([self.line(), rhs_concat])),
+                        self.concat([self.space(), rhs_concat]),
                     ]
                 )
             )
@@ -375,6 +388,20 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif i == node.condition and isinstance(i, uni.BoolExpr):
+                cond_str = i.gen.doc_ir
+                flat = self.concat([cond_str, self.space()])
+                broken = self.group(
+                    self.concat(
+                        [
+                            self.text("("),
+                            self.indent(self.concat([self.line(), cond_str])),
+                            self.line(),
+                            self.text(")"),
+                        ]
+                    )
+                )
+                parts.append(self.if_break(broken, flat))
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -397,6 +424,21 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif i == node.condition and isinstance(i, uni.BoolExpr):
+                cond_str = i.gen.doc_ir
+                flat = self.concat([cond_str, self.space()])
+                broken = self.group(
+                    self.concat(
+                        [
+                            self.text("("),
+                            self.indent(self.concat([self.line(), cond_str])),
+                            self.line(),
+                            self.text(")"),
+                            self.space(),
+                        ]
+                    )
+                )
+                parts.append(self.if_break(broken, flat))
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -471,8 +513,18 @@ class DocIRGenPass(UniPass):
                 parts.append(i.gen.doc_ir)
             elif isinstance(i, uni.Token) and i.name == Tok.RPAREN and node.params:
                 in_params = False
+
+                if isinstance(indent_parts[-1], doc.Line):
+                    indent_parts.pop()
                 parts.append(
-                    self.indent(self.concat([self.tight_line(), *indent_parts]))
+                    self.indent(
+                        self.concat(
+                            [
+                                self.tight_line(),
+                                self.group(self.concat([*indent_parts])),
+                            ]
+                        )
+                    )
                 )
                 parts.append(self.tight_line())
                 parts.append(i.gen.doc_ir)
@@ -510,12 +562,16 @@ class DocIRGenPass(UniPass):
             if isinstance(i, uni.Token) and i.name == Tok.COMMA:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
-            elif isinstance(i, uni.Token) and i.name == Tok.LSQUARE:
-                parts.append(self.hard_line())
-                parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
-        broke = self.concat(parts)
+        broke = self.concat(
+            [
+                parts[0],
+                self.indent(self.concat([self.hard_line(), *parts[1:-1]])),
+                self.hard_line(),
+                parts[-1],
+            ]
+        )
         node.gen.doc_ir = self.group(self.if_break(broke, not_broke))
 
     def exit_dict_val(self, node: uni.DictVal) -> None:
@@ -699,12 +755,16 @@ class DocIRGenPass(UniPass):
             if isinstance(i, uni.Token) and i.name == Tok.COMMA:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.hard_line())
-            elif isinstance(i, uni.Token) and i.name == Tok.LPAREN:
-                parts.append(self.hard_line())
-                parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
-        broke = self.concat(parts)
+        broke = self.concat(
+            [
+                parts[0],
+                self.indent(self.concat([self.hard_line(), *parts[1:-1]])),
+                self.hard_line(),
+                parts[-1],
+            ]
+        )
         node.gen.doc_ir = self.group(self.if_break(broke, not_broke))
 
     def exit_multi_string(self, node: uni.MultiString) -> None:
@@ -748,17 +808,34 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for list comprehensions."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
+            if isinstance(i, uni.InnerCompr):
+                parts.append(self.group(self.concat([self.tight_line(), i.gen.doc_ir])))
+            else:
+                parts.append(i.gen.doc_ir)
             parts.append(self.space())
         parts.pop()
-        node.gen.doc_ir = self.group(self.concat(parts))
+        node.gen.doc_ir = self.group(
+            self.concat(
+                [
+                    parts[0],
+                    self.indent(self.concat([self.tight_line(), *parts[2:-2]])),
+                    self.tight_line(),
+                    parts[-1],
+                ]
+            )
+        )
 
     def exit_inner_compr(self, node: uni.InnerCompr) -> None:
         """Generate DocIR for inner comprehension clauses."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
-            parts.append(self.space())
+            if isinstance(i, uni.Token) and i.name == Tok.KW_IF:
+                parts.append(self.hard_line())
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
+            else:
+                parts.append(i.gen.doc_ir)
+                parts.append(self.space())
         parts.pop()
         node.gen.doc_ir = self.group(self.concat(parts))
 
@@ -772,6 +849,7 @@ class DocIRGenPass(UniPass):
     def exit_if_else_expr(self, node: uni.IfElseExpr) -> None:
         """Generate DocIR for conditional expressions."""
         parts: list[doc.DocType] = []
+        need_parens = not isinstance(node.parent, uni.AtomUnit)
 
         for i in node.kid:
             if isinstance(i, uni.Expr):
@@ -782,21 +860,60 @@ class DocIRGenPass(UniPass):
                 parts.append(self.space())
             else:
                 parts.append(i.gen.doc_ir)
-                parts.append(self.space())
+                parts.append(self.line())
         parts.pop()
-        node.gen.doc_ir = self.group(self.concat(parts))
+
+        flat = self.group(self.concat(parts))
+        parens = self.group(
+            self.concat(
+                [
+                    self.text("("),
+                    self.indent(self.concat([self.tight_line(), flat])),
+                    self.tight_line(),
+                    self.text(")"),
+                ]
+            )
+        )
+        node.gen.doc_ir = flat
+
+        if need_parens:
+            if isinstance(node.parent, uni.Assignment):
+                node.gen.doc_ir = self.if_break(
+                    break_contents=parens, flat_contents=flat
+                )
+            else:
+                node.gen.doc_ir = parens
 
     def exit_bool_expr(self, node: uni.BoolExpr) -> None:
         """Generate DocIR for boolean expressions (and/or)."""
+        exprs: list[uni.UniNode] = []
         parts: list[doc.DocType] = []
-        for i in node.kid:
-            if isinstance(i, uni.Token):
-                parts.append(i.gen.doc_ir)
-                parts.append(self.space())
+
+        def __flatten_bool_expr(expr: uni.Expr) -> list[uni.UniNode]:
+            if isinstance(expr, uni.BoolExpr):
+                out: list[uni.UniNode] = []
+                for val in expr.values:
+                    out += __flatten_bool_expr(val)
+                    out.append(expr.op)
+                out.pop()
+                return out
             else:
-                parts.append(i.gen.doc_ir)
-                parts.append(self.line())  # Potential break
-        node.gen.doc_ir = self.group(self.concat(parts))
+                return [expr]
+
+        exprs = __flatten_bool_expr(node)
+        for i in range(0, len(exprs) - 1, 2):
+            (
+                expr,
+                op,
+            ) = (
+                exprs[i],
+                exprs[i + 1],
+            )
+            parts += [expr.gen.doc_ir, self.space(), op.gen.doc_ir, self.line()]
+        parts += [exprs[-1].gen.doc_ir, self.line()]
+        parts.pop()
+        flat = self.concat(parts)
+        node.gen.doc_ir = self.group(flat)
 
     def exit_unary_expr(self, node: uni.UnaryExpr) -> None:
         """Generate DocIR for unary expressions."""
@@ -860,27 +977,49 @@ class DocIRGenPass(UniPass):
         parts: list[doc.DocType] = []
         for i in node.kid:
             parts.append(i.gen.doc_ir)
-            parts.append(self.space())
-        parts.pop()
         node.gen.doc_ir = self.group(self.concat(parts))
 
     def exit_gen_compr(self, node: uni.GenCompr) -> None:
         """Generate DocIR for generator comprehensions."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
+            if isinstance(i, uni.InnerCompr):
+                parts.append(self.group(self.concat([self.tight_line(), i.gen.doc_ir])))
+            else:
+                parts.append(i.gen.doc_ir)
             parts.append(self.space())
         parts.pop()
-        node.gen.doc_ir = self.group(self.concat(parts))
+        node.gen.doc_ir = self.group(
+            self.concat(
+                [
+                    parts[0],
+                    self.indent(self.concat([self.tight_line(), *parts[2:-2]])),
+                    self.tight_line(),
+                    parts[-1],
+                ]
+            )
+        )
 
     def exit_set_compr(self, node: uni.SetCompr) -> None:
         """Generate DocIR for set comprehensions."""
         parts: list[doc.DocType] = []
         for i in node.kid:
-            parts.append(i.gen.doc_ir)
+            if isinstance(i, uni.InnerCompr):
+                parts.append(self.group(self.concat([self.tight_line(), i.gen.doc_ir])))
+            else:
+                parts.append(i.gen.doc_ir)
             parts.append(self.space())
         parts.pop()
-        node.gen.doc_ir = self.group(self.concat(parts))
+        node.gen.doc_ir = self.group(
+            self.concat(
+                [
+                    parts[0],
+                    self.indent(self.concat([self.tight_line(), *parts[2:-2]])),
+                    self.tight_line(),
+                    parts[-1],
+                ]
+            )
+        )
 
     def exit_dict_compr(self, node: uni.DictCompr) -> None:
         """Generate DocIR for dictionary comprehensions."""
@@ -889,10 +1028,24 @@ class DocIRGenPass(UniPass):
             if isinstance(i, uni.Token) and i.name in [Tok.STAR_POW, Tok.STAR_MUL]:
                 parts.append(i.gen.doc_ir)
             else:
-                parts.append(i.gen.doc_ir)
+                if isinstance(i, uni.InnerCompr):
+                    parts.append(
+                        self.group(self.concat([self.tight_line(), i.gen.doc_ir]))
+                    )
+                else:
+                    parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         parts.pop()
-        node.gen.doc_ir = self.group(self.concat(parts))
+        node.gen.doc_ir = self.group(
+            self.concat(
+                [
+                    parts[0],
+                    self.indent(self.concat([self.tight_line(), *parts[2:-2]])),
+                    self.tight_line(),
+                    parts[-1],
+                ]
+            )
+        )
 
     def exit_k_w_pair(self, node: uni.KWPair) -> None:
         """Generate DocIR for keyword arguments."""
@@ -1101,7 +1254,23 @@ class DocIRGenPass(UniPass):
                 parts.append(self.space())
             prev_item = i
         parts.pop()
-        node.gen.doc_ir = self.group(self.concat(parts))
+        broken = self.group(
+            self.concat(
+                [
+                    parts[0],
+                    self.indent(self.concat([self.tight_line(), *parts[1:-1]])),
+                    self.tight_line(),
+                    parts[-1],
+                ]
+            )
+        )
+        if isinstance(node.parent, uni.Assignment):
+            node.gen.doc_ir = self.if_break(
+                flat_contents=self.group(self.concat(parts[1:-1])),
+                break_contents=broken,
+            )
+        else:
+            node.gen.doc_ir = broken
 
     def exit_expr_as_item(self, node: uni.ExprAsItem) -> None:
         """Generate DocIR for expression as item nodes."""
@@ -1109,6 +1278,7 @@ class DocIRGenPass(UniPass):
         for i in node.kid:
             parts.append(i.gen.doc_ir)
             parts.append(self.space())
+        parts.pop()
         node.gen.doc_ir = self.group(self.concat(parts))
 
     def exit_filter_compr(self, node: uni.FilterCompr) -> None:
@@ -1160,16 +1330,6 @@ class DocIRGenPass(UniPass):
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
 
-    def exit_check_stmt(self, node: uni.CheckStmt) -> None:
-        """Generate DocIR for check statements."""
-        parts: list[doc.DocType] = []
-        for i in node.kid:
-            if isinstance(i, uni.Token) and i.name == Tok.SEMI:
-                parts.pop()
-            parts.append(i.gen.doc_ir)
-            parts.append(self.space())
-        node.gen.doc_ir = self.group(self.concat(parts))
-
     def exit_match_stmt(self, node: uni.MatchStmt) -> None:
         """Generate DocIR for match statements."""
         parts: list[doc.DocType] = []

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -3,7 +3,8 @@
 This is a pass for formatting Jac code.
 """
 
-from typing import Optional
+from collections import deque
+from typing import Deque, Optional, Tuple
 
 import jaclang.compiler.passes.tool.doc_ir as doc
 import jaclang.compiler.unitree as uni
@@ -19,6 +20,83 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
         self.indent_size = 4
         self.MAX_LINE_LENGTH = settings.max_line_length
 
+    def _probe_fits(
+        self,
+        node: doc.DocType,
+        indent_level: int,
+        width_remaining: int,
+        *,
+        max_steps: int = 2000,
+    ) -> bool:
+        """
+        Check if flat can be used early.
+
+        returns True if `node` could be printed *flat* on the current line within
+        `width_remaining` columns at `indent_level`.
+        Stops early on overflow or hard/literal lines.
+        """
+        # Worklist holds (node, indent_level). We only ever push FLAT in a probe.
+        work: Deque[Tuple[object, int]] = deque()
+        work.append((node, indent_level))
+        steps = 0
+        remaining = width_remaining
+
+        while work:
+            if steps >= max_steps:
+                # Safety cutoff: if it's *that* complex, assume it doesn't fit.
+                return False
+            steps += 1
+
+            cur, lvl = work.pop()
+
+            if isinstance(cur, doc.Text):
+                remaining -= len(cur.text)
+                if remaining < 0:
+                    return False
+
+            elif isinstance(cur, doc.Line):
+                if cur.hard or cur.literal:
+                    # Any *real* newline (hard or literal) in FLAT means "doesn't fit"
+                    return False
+                if cur.tight:
+                    # tight softline disappears in flat mode
+                    continue
+                # regular soft line becomes a single space in flat mode
+                remaining -= 1
+                if remaining < 0:
+                    return False
+
+            # --- Structural nodes (walk children in LIFO) ---
+            elif isinstance(cur, doc.Concat):
+                # push reversed so we process left-to-right as work is a stack
+                for p in reversed(cur.parts):
+                    work.append((p, lvl))
+
+            elif isinstance(cur, doc.Group):
+                # Probe is always FLAT for groups.
+                work.append((cur.contents, lvl))
+
+            elif isinstance(cur, doc.Indent):
+                # In flat mode, indentation has no effect until a newline; keep lvl in case
+                # children contain Lines (which would have already returned False).
+                work.append((cur.contents, lvl + 1))
+
+            elif isinstance(cur, doc.Align):
+                # In flat mode, alignment doesn’t change width immediately (no newline),
+                # but we carry its virtual indent so nested (illegal) Line would be caught.
+                align_spaces = cur.n if cur.n is not None else self.indent_size
+                extra_levels = align_spaces // self.indent_size
+                work.append((cur.contents, lvl + extra_levels))
+
+            elif isinstance(cur, doc.IfBreak):
+                # Flat branch while probing
+                work.append((cur.flat_contents, lvl))
+
+            else:
+                raise ValueError(f"Unknown DocType in probe: {type(cur)}")
+
+        return True
+
     def transform(self, ir_in: uni.Module) -> uni.Module:
         """After pass."""
         ir_in.gen.jac = self.format_doc_ir()
@@ -52,106 +130,78 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
                 return " "
 
         elif isinstance(doc_node, doc.Group):
-            # Try to print flat first. For this attempt, the group itself isn't forced to break.
-            flat_contents_str = self.format_doc_ir(
-                doc_node.contents, indent_level, width_remaining, is_broken=False
+            fits_flat = self._probe_fits(
+                doc_node.contents,
+                indent_level=indent_level,
+                width_remaining=width_remaining,
+            )
+            return self.format_doc_ir(
+                doc_node.contents,
+                indent_level,
+                width_remaining,
+                is_broken=not fits_flat,
             )
-            if (
-                "\n" not in flat_contents_str
-                and len(flat_contents_str) <= width_remaining
-            ):
-                return flat_contents_str
-            else:
-                full_width_for_broken_content = self.MAX_LINE_LENGTH - (
-                    indent_level * self.indent_size
-                )
-                return self.format_doc_ir(
-                    doc_node.contents,
-                    indent_level,
-                    full_width_for_broken_content,
-                    is_broken=True,
-                )
 
         elif isinstance(doc_node, doc.Indent):
             new_indent_level = indent_level + 1
-
-            width_for_indented_content = self.MAX_LINE_LENGTH - (
-                new_indent_level * self.indent_size
-            )
             return self.format_doc_ir(
                 doc_node.contents,
                 new_indent_level,
-                width_for_indented_content,  # Budget for lines within indent
+                width_remaining,  # width_for_indented_content  # Budget for lines within indent
                 is_broken,  # is_broken state propagates
             )
 
         elif isinstance(doc_node, doc.Concat):
-            result = ""
-            # current_line_budget is the space left on the current line for the current part.
+            result: list[str] = []
             current_line_budget = width_remaining
 
             for part in doc_node.parts:
                 part_str = self.format_doc_ir(
                     part, indent_level, current_line_budget, is_broken
                 )
-                if part_str.startswith("\n"):
-                    result = result.rstrip(" ")
-                result += part_str
+
+                # Trim trailing spaces when a newline begins next
+                if part_str.startswith("\n") and result and result[-1].endswith(" "):
+                    result[-1] = result[-1].rstrip(" ")
+
+                result.append(part_str)
 
                 if "\n" in part_str:
-                    # part_str created a newline. The next part starts on a new line.
-                    # Its budget is the full width available at this indent level.
-                    current_line_budget = self.MAX_LINE_LENGTH - (
-                        indent_level * self.indent_size
+                    # After a newline, reset budget to full width at this indent.
+                    last_line = part_str.splitlines()[-1]
+                    full_budget = max(
+                        0, self.MAX_LINE_LENGTH - indent_level * self.indent_size
                     )
-                    # Subtract what the *last line* of part_str consumed from this budget.
-                    # The characters on the last line after the indent string.
-                    indent_str_len = indent_level * self.indent_size
-                    last_line_of_part = part_str.splitlines()[-1]
-
-                    content_on_last_line = 0
-                    if last_line_of_part.startswith(" " * indent_str_len):
-                        content_on_last_line = len(last_line_of_part) - indent_str_len
-                    else:  # It was a line not starting with the full indent (e.g. literal \n)
-                        content_on_last_line = len(last_line_of_part)
-
-                    current_line_budget -= content_on_last_line
+                    # Compute how many chars are already on the last line (after indent).
+                    indent_spaces = " " * (indent_level * self.indent_size)
+                    if last_line.startswith(indent_spaces):
+                        used = len(last_line) - len(indent_spaces)
+                    else:
+                        used = len(last_line)
+                    current_line_budget = max(0, full_budget - used)
                 else:
-                    # part_str stayed on the same line. Reduce budget for next part on this line.
-                    current_line_budget -= len(part_str)
+                    current_line_budget = max(0, current_line_budget - len(part_str))
 
-                if current_line_budget < 0:  # Ensure budget isn't negative
-                    current_line_budget = 0
-            return result
+            return "".join(result)
 
         elif isinstance(doc_node, doc.IfBreak):
-            if is_broken:
-                return self.format_doc_ir(
-                    doc_node.break_contents, indent_level, width_remaining, is_broken
-                )
-            else:
-                return self.format_doc_ir(
-                    doc_node.flat_contents, indent_level, width_remaining, is_broken
-                )
+            branch = doc_node.break_contents if is_broken else doc_node.flat_contents
+            return self.format_doc_ir(branch, indent_level, width_remaining, is_broken)
 
         elif isinstance(doc_node, doc.Align):
             align_spaces = doc_node.n if doc_node.n is not None else self.indent_size
-            # effective_total_indent_spaces_for_children = (
-            #     indent_level * self.indent_size
-            # ) + align_spaces
-            child_indent_level_for_align = indent_level + (
-                align_spaces // self.indent_size
-            )
+            extra_levels = align_spaces // self.indent_size
+            child_indent_level = indent_level + extra_levels
 
-            child_width_budget = width_remaining - align_spaces
-            if child_width_budget < 0:
-                child_width_budget = 0
+            # On the same line, alignment "consumes" part of the current budget.
+            child_width_budget = max(0, width_remaining - align_spaces)
 
             return self.format_doc_ir(
                 doc_node.contents,
-                child_indent_level_for_align,  # Approximated level for Lines inside
-                child_width_budget,  # Budget for content on first line
+                child_indent_level,
+                child_width_budget,
                 is_broken,
             )
+
         else:
             raise ValueError(f"Unknown DocType: {type(doc_node)}")

jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac

@@ -474,15 +474,15 @@ impl JacPlugin.visit_node
 glob expected_area = 78.53981633974483;
 
 test a1 {
-    check assertAlmostEqual(calculate_area(RAD), expected_area);
+    assert assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
 test a2 {
     c = Circle(RAD);
-    check assertAlmostEqual(c.area(), expected_area);
+    assert assertAlmostEqual(c.area(), expected_area);
 }
 
 test a3 {
     c = Circle(RAD);
-    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+    assert assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/triple_quoted_string.jac

@@ -1,7 +1,6 @@
 with entry {
-    triple_quoted_string =
-        """This is a triple quoted string.
-        It can span multiple lines.
-        It can contain any number of quotes or apostrophes.
-        """;
+    triple_quoted_string = """This is a triple quoted string.
+    It can span multiple lines.
+    It can contain any number of quotes or apostrophes.
+    """;
 }