fix(compiler): prevent line wrapping in language-specific syntax constructs

- Add wrap_line/wrap_lines methods to BaseGenerator for smart line breaking
- Override wrap_line in Go generator to preserve function signatures and struct tags
- Override wrap_line in Python generator to preserve assignments and conditionals
- Modify Java generator to use string concatenation for long error messages
- Fix ruff formatting issues (multi-line if statements, trailing whitespace)

This fixes syntax errors in generated IDL code across Java, Go, and Python.

Author: Lavisha Gupta

compiler/fory_compiler/generators/base.py

@@ -239,7 +239,12 @@ def wrap_line(
             return [line]
 
         # Don't wrap comment lines (license headers, etc.)
-        if stripped.startswith("//") or stripped.startswith("/*") or stripped.startswith("*") or stripped.startswith("#"):
+        if (
+            stripped.startswith("//")
+            or stripped.startswith("/*")
+            or stripped.startswith("*")
+            or stripped.startswith("#")
+        ):
             return [line]
 
         # Extract the leading indent
@@ -275,7 +280,18 @@ def wrap_line(
             search_text = current[:available]
 
             # Try to break at common delimiters (working backwards)
-            for delimiter in [", ", " && ", " || ", " + ", " - ", " * ", " / ", " = ", " ", ","]:
+            for delimiter in [
+                ", ",
+                " && ",
+                " || ",
+                " + ",
+                " - ",
+                " * ",
+                " / ",
+                " = ",
+                " ",
+                ",",
+            ]:
                 idx = search_text.rfind(delimiter)
                 if idx > 0:
                     break_point = idx + len(delimiter)

compiler/fory_compiler/generators/go.py

@@ -207,34 +207,34 @@ def wrap_line(
         continuation_indent: str = None,
     ) -> List[str]:
         """Override base wrap_line to handle Go-specific syntax.
-        
+
         Go has specific constructs that should not be wrapped:
         1. Function signatures - must not split between params and return type
         2. Struct field tags - backtick strings must not be split
         3. Single-line function bodies - must not split "{ return ... }"
         """
         if continuation_indent is None:
             continuation_indent = indent + "    "
-        
+
         # If line is already short enough, return as is
         if len(line) <= max_width:
             return [line]
-        
+
         stripped = line.lstrip()
-        
+
         # Don't wrap comments
         if stripped.startswith("//") or stripped.startswith("/*") or stripped.startswith("*"):
             return [line]
-        
+
         # Don't wrap lines with backticks (struct tags)
         if "`" in line:
             return [line]
-        
+
         # Don't wrap function definitions (including one-liners like "func Foo() Type { return ... }")
         # Detect by checking if line starts with "func " and contains "{"
         if stripped.startswith("func ") and "{" in line:
             return [line]
-        
+
         # For all other cases, use base class wrapping
         return super().wrap_line(line, max_width, indent, continuation_indent)
 
@@ -902,7 +902,7 @@ def generate_field(
         if tags:
             tag_str = ",".join(tags)
             # Concatenate parts to ensure single line in output
-            lines.append(f"{field_name} {go_type} `fory:\"{tag_str}\"`")
+            lines.append(f'{field_name} {go_type} `fory:"{tag_str}"`')
         else:
             lines.append(f"{field_name} {go_type}")
 

compiler/fory_compiler/generators/python.py

@@ -149,46 +149,53 @@ def wrap_line(
         continuation_indent: str = None,
     ) -> List[str]:
         """Override base wrap_line to handle Python-specific syntax.
-        
+
         Python has specific constructs that should not be wrapped:
         1. Assignment statements - must not split between variable and value
         2. Conditional statements with logical operators (and, or, not)
         3. Raise statements with string literals
         """
         if continuation_indent is None:
             continuation_indent = indent + "    "
-        
+
         # If line is already short enough, return as is
         if len(line) <= max_width:
             return [line]
-        
+
         stripped = line.lstrip()
-        
+
         # Don't wrap comments
         if stripped.startswith("#"):
             return [line]
-        
+
         # Don't wrap raise statements (they often have long string literals)
         if stripped.startswith("raise "):
             return [line]
-        
+
         # Don't wrap assignment statements (lines containing " = " at the statement level)
         # This prevents splitting like: _threadsafe_fory = pyfory.ThreadSafeFory(...)
         # Only check for simple assignments (not comparisons or keyword args)
-        if " = " in line and not line.strip().startswith("if ") and not line.strip().startswith("elif ") and not line.strip().startswith("while "):
+        if (
+            " = " in line
+            and not line.strip().startswith("if ")
+            and not line.strip().startswith("elif ")
+            and not line.strip().startswith("while ")
+        ):
             # Check if this looks like a simple assignment (has = but not == or <= or >=)
             # and the = comes before any opening parentheses
             eq_pos = line.find(" = ")
             paren_pos = line.find("(")
             if eq_pos > 0 and (paren_pos < 0 or eq_pos < paren_pos):
                 # This is likely an assignment statement, don't wrap it
                 return [line]
-        
+
         # Don't wrap conditional statements (if/elif/while) with logical operators
         # This prevents splitting like: if condition and not\n    isinstance(...)
-        if stripped.startswith(("if ", "elif ", "while ")) and (" and " in line or " or " in line):
+        if stripped.startswith(("if ", "elif ", "while ")) and (
+            " and " in line or " or " in line
+        ):
             return [line]
-        
+
         # For all other cases, use base class wrapping
         return super().wrap_line(line, max_width, indent, continuation_indent)