fix spacing: verbatim inter-token copy, fix postfix decompile, add integration tests

tests/test_integration.py

@@ -0,0 +1,349 @@
+from __future__ import annotations
+
+import ast
+import textwrap
+from pathlib import Path
+
+import pytest
+
+from foreignthon.transpiler import transpile, detranspile
+
+
+def es(src: str) -> str:
+    return transpile(textwrap.dedent(src).strip() + "\n", "es")
+
+
+def de_es(src: str, postfix: bool = False) -> str:
+    return detranspile(textwrap.dedent(src).strip() + "\n", "es", postfix=postfix)
+
+
+def valid(src: str) -> bool:
+    try:
+        ast.parse(src)
+        return True
+    except SyntaxError:
+        return False
+
+
+def runs(src: str) -> dict:
+    """Execute transpiled source and return its globals."""
+    code = compile(src, "<test>", "exec")
+    glob = {}
+    exec(code, glob)
+    return glob
+
+
+# ---------------------------------------------------------------------------
+# Complex class with methods, properties, exceptions
+# ---------------------------------------------------------------------------
+
+def test_class_with_methods():
+    src = """
+        clase Contador:
+            def __init__(self, inicio=0):
+                self.valor = inicio
+
+            def incrementar(self):
+                self.valor += 1
+                retornar self.valor
+
+            def reiniciar(self):
+                self.valor = 0
+
+        c = Contador(10)
+        c.incrementar()
+        c.incrementar()
+    """
+    out = es(src)
+    assert valid(out)
+    g = runs(out)
+    assert g["c"].valor == 12
+
+
+# ---------------------------------------------------------------------------
+# Exception handling with custom exception
+# ---------------------------------------------------------------------------
+
+def test_exception_handling():
+    src = """
+        clase MiError(Excepcion):
+            pasar
+
+        def dividir(a, b):
+            si b == 0:
+                lanzar ErrorDeDivisionCero("no dividas por cero")
+            retornar a / b
+
+        intentar:
+            resultado = dividir(10, 2)
+        excepto ErrorDeDivisionCero como e:
+            resultado = -1
+        finalmente:
+            hecho = Verda
+    """
+    out = es(src)
+    assert valid(out)
+    g = runs(out)
+    assert g["resultado"] == 5.0
+    assert g["hecho"] is True
+
+
+# ---------------------------------------------------------------------------
+# Generator with yield
+# ---------------------------------------------------------------------------
+
+def test_generator():
+    src = """
+        def cuadrados(n):
+            para i en dist(n):
+                generar i * i
+
+        resultado = lista(cuadrados(5))
+    """
+    out = es(src)
+    assert valid(out)
+    g = runs(out)
+    assert g["resultado"] == [0, 1, 4, 9, 16]
+
+
+# ---------------------------------------------------------------------------
+# Lambda and higher order functions
+# ---------------------------------------------------------------------------
+
+def test_lambda_and_builtins():
+    src = """
+        nums = [3, 1, 4, 1, 5, 9, 2, 6]
+        pares = lista(filtrar(lambda x: x % 2 == 0, nums))
+        dobles = lista(map(lambda x: x * 2, nums))
+        total = sum(nums)
+        mayor = max(nums)
+        menor = min(nums)
+    """
+    out = es(src)
+    assert valid(out)
+    g = runs(out)
+    assert g["pares"] == [4, 2, 6]
+    assert g["total"] == 31
+    assert g["mayor"] == 9
+    assert g["menor"] == 1
+
+
+# ---------------------------------------------------------------------------
+# Nested functions and closures
+# ---------------------------------------------------------------------------
+
+def test_nested_functions():
+    src = """
+        def hacer_multiplicador(n):
+            def multiplicar(x):
+                retornar x * n
+            retornar multiplicar
+
+        doble = hacer_multiplicador(2)
+        triple = hacer_multiplicador(3)
+        resultado = doble(5) + triple(4)
+    """
+    out = es(src)
+    assert valid(out)
+    g = runs(out)
+    assert g["resultado"] == 22
+
+
+# ---------------------------------------------------------------------------
+# While loop with break and continue
+# ---------------------------------------------------------------------------
+
+def test_while_break_continue():
+    src = """
+        resultado = []
+        i = 0
+        mientras i < 20:
+            i += 1
+            si i % 2 == 0:
+                continuar
+            si i > 9:
+                parar
+            resultado.append(i)
+    """
+    out = es(src)
+    assert valid(out)
+    g = runs(out)
+    assert g["resultado"] == [1, 3, 5, 7, 9]
+
+
+# ---------------------------------------------------------------------------
+# List/dict/set comprehensions
+# ---------------------------------------------------------------------------
+
+def test_comprehensions():
+    src = """
+        cuadrados = [x*x para x en dist(6)]
+        pares = {x para x en dist(10) si x % 2 == 0}
+        cubo_dict = {x: x**3 para x en dist(5)}
+    """
+    out = es(src)
+    assert valid(out)
+    g = runs(out)
+    assert g["cuadrados"] == [0, 1, 4, 9, 16, 25]
+    assert g["pares"] == {0, 2, 4, 6, 8}
+    assert g["cubo_dict"] == {0: 0, 1: 1, 2: 8, 3: 27, 4: 64}
+
+
+# ---------------------------------------------------------------------------
+# @@ postfix syntax — mixed with prefix
+# ---------------------------------------------------------------------------
+
+def test_postfix_mixed_with_prefix():
+    src = """
+        def clasificar(n):
+            n > 0 @@si:
+                retornar "positivo"
+            n < 0 @@osi:
+                retornar "negativo"
+            sino:
+                retornar "cero"
+
+        resultados = [clasificar(x) para x en [-2, 0, 3]]
+    """
+    out = es(src)
+    assert valid(out)
+    assert "@@" not in out
+    g = runs(out)
+    assert g["resultados"] == ["negativo", "cero", "positivo"]
+
+
+# ---------------------------------------------------------------------------
+# @@ postfix in while and nested ifs
+# ---------------------------------------------------------------------------
+
+def test_postfix_while_nested():
+    src = """
+        acum = 0
+        i = 1
+        i <= 10 @@mientras:
+            i % 2 == 0 @@si:
+                acum += i
+            i += 1
+    """
+    out = es(src)
+    assert valid(out)
+    assert "@@" not in out
+    g = runs(out)
+    assert g["acum"] == 30  # 2+4+6+8+10
+
+
+# ---------------------------------------------------------------------------
+# Strings and comments never touched
+# ---------------------------------------------------------------------------
+
+def test_strings_with_keyword_names():
+    src = """
+        msg = "si para mientras def class"
+        comentario = 'si esto no se traduce'
+        fstr = f"valor si={42}"
+        lista_kw = ["si", "para", "mientras"]
+    """
+    out = es(src)
+    assert '"si para mientras def class"' in out
+    assert "'si esto no se traduce'" in out
+    assert '["si", "para", "mientras"]' in out
+
+
+def test_comment_lines_untouched():
+    src = """
+        # si para mientras escribir dist
+        x = 1  # si esto es un comentario
+        y = 2
+    """
+    out = es(src)
+    assert "# si para mientras escribir dist" in out
+    assert "# si esto es un comentario" in out
+
+
+# ---------------------------------------------------------------------------
+# Spacing — no double blank lines, no spaces around parens
+# ---------------------------------------------------------------------------
+
+def test_no_double_blank_lines():
+    src = """
+        def foo():
+            pasar
+
+        def bar():
+            pasar
+
+        def baz():
+            pasar
+    """
+    out = es(src)
+    assert "\n\n\n" not in out
+
+
+def test_no_spaces_around_parens():
+    src = "escribir(dist(10))\n"
+    out = es(src)
+    assert "print(range(10))" in out
+
+
+# ---------------------------------------------------------------------------
+# Decompile — round trip
+# ---------------------------------------------------------------------------
+
+
+def test_decompile_postfix():
+    src = textwrap.dedent("""
+        def check(x):
+            if x > 0:
+                print(x)
+            elif x == 0:
+                print(0)
+            else:
+                pass
+    """).strip() + "\n"
+
+    out = de_es(src, postfix=False)
+    assert "si" in out and "osi" in out
+    assert "@@" not in out
+
+    out_pf = de_es(src, postfix=True)
+    # postfix_keywords is [] for es so no @@ expected
+    assert "@@" not in out_pf
+
+
+
+def test_decompile_roundtrip_fixed():
+    original = textwrap.dedent("""
+        def sumar(a, b):
+            return a + b
+
+        for i in range(5):
+            print(sumar(i, 1))
+    """).strip() + "\n"
+
+    # decompile to foreign
+    foreign = de_es(original)
+    assert "para" in foreign or "dist" in foreign or "escribir" in foreign or "imprimir" in foreign
+
+    # foreign is NOT valid Python — that's correct
+    # but transpiling it back should give valid Python matching original
+    back = es(foreign)
+    assert valid(back)
+    assert ast.dump(ast.parse(original)) == ast.dump(ast.parse(back))
+
+
+def test_decompile_exceptions_fixed():
+    src = textwrap.dedent("""
+        try:
+            x = 1 / 0
+        except ZeroDivisionError:
+            x = 0
+    """).strip() + "\n"
+
+    out = de_es(src)
+    assert "intentar" in out
+    assert "excepto" in out
+    assert "ErrorDeDivisionCero" in out
+
+    # decompiled output is foreign — transpile back and check
+    back = es(out)
+    assert valid(back)