Typhon-Language 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

Typhon/Driver/configs.py

@@ -0,0 +1,14 @@
+from typing import Literal
+
+_language_backend: Literal["pyrefly", "pyright"] = "pyrefly"
+# TODO: Basedpyright seems to hang on semantic tokens request
+_language_backend = "pyright"
+
+
+def set_language_backend(backend: Literal["pyrefly", "pyright"]):
+    global _language_backend
+    _language_backend = backend
+
+
+def get_language_backend() -> Literal["pyrefly", "pyright"]:
+    return _language_backend

Typhon/Driver/debugging.py

@@ -1,8 +1,13 @@
-from .utils import copy_type
+from .utils import copy_type, get_project_root
+from typing import BinaryIO, override
+from pathlib import Path
+import logging
+
 
 _debug = False
 _debug_verbose = False
 _debug_first_error = False
+_debug_log_file: Path | None = None
 
 
 def set_debug_mode(debug: bool):
@@ -22,6 +27,20 @@ def set_debug_first_error(first_error: bool):
     _debug_first_error = first_error
 
 
+def set_debug_log_file(
+    log_file: str | None, verbose: bool = False, append: bool = False
+):
+    global _debug_log_file
+    _debug_log_file = Path(log_file) if log_file else None
+    if _debug_log_file is not None:
+        if verbose:
+            set_debug_verbose(True)
+        set_debug_mode(True)
+        mode = "a" if append else "w"
+        with _debug_log_file.open(mode) as f:
+            f.write("=== Typhon Debug Log ===\n")
+
+
 def is_debug_mode() -> bool:
     return _debug
 
@@ -35,13 +54,137 @@ def is_debug_first_error() -> bool:
     return _debug_first_error
 
 
+def get_debug_log_file() -> Path | None:
+    return _debug_log_file
+
+
+_debug_printed: int = 0
+_debug_printed_size: int = 0
+_limit_reached_printed: bool = False
+
+
+def _debug_limit_check(*arg) -> bool:
+    global _debug_printed
+    global _debug_printed_size
+    global _limit_reached_printed
+    if _debug_printed > 100000 or _debug_printed_size > 10000000:
+        if not _limit_reached_printed:
+            print("Debug print limit reached, stopping further debug prints.")
+            _limit_reached_printed = True
+        return True
+    _debug_printed += 1
+    _debug_printed_size += sum(len(str(a)) for a in arg)
+    return False
+
+
+@copy_type(print)
+def debug_print(*arg, **kwargs) -> None:  # type: ignore
+    if _debug:
+        if _debug_limit_check(*arg):
+            return
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
+        else:
+            print(*arg, **kwargs)  # type: ignore
+
+
+@copy_type(print)
+def debug_verbose_print(*arg, **kwargs) -> None:  # type: ignore
+    if _debug_verbose:
+        if _debug_limit_check(*arg):
+            return
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
+        else:
+            print(*arg, **kwargs)  # type: ignore
+
+
 @copy_type(print)
-def debug_print(*arg, **kwargs) -> None:
+def debug_file_write(*arg, **kwargs) -> None:  # type: ignore
     if _debug:
-        print(*arg, **kwargs)
+        if _debug_log_file is not None:
+            if _debug_limit_check(*arg):
+                return
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
 
 
 @copy_type(print)
-def debug_verbose_print(*arg, **kwargs) -> None:
+def debug_file_write_verbose(*arg, **kwargs) -> None:  # type: ignore
     if _debug_verbose:
-        print(*arg, **kwargs)
+        if _debug_log_file is not None:
+            if _debug_limit_check(*arg):
+                return
+            with _debug_log_file.open("a") as log_file:
+                print(*arg, file=log_file, **kwargs)  # type: ignore
+
+
+type ReadableBuffer = bytes | bytearray | memoryview
+
+
+# Bypass binaryIO class stdio to log
+class BinaryIOLogger(BinaryIO):
+    def __init__(self, pipe: BinaryIO):
+        self._pipe = pipe
+
+    def fileno(self) -> int:
+        return self._pipe.fileno()
+
+    def isatty(self) -> bool:
+        return self._pipe.isatty()
+
+    def write(self, data: ReadableBuffer) -> int:
+        # Log the data being written
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write(f"Writing {data}\n")
+                log_file.flush()
+        return self._pipe.write(data)
+
+    def flush(self) -> None:
+        self._pipe.flush()
+
+    def read(self, n: int = -1) -> bytes:
+        data = self._pipe.read(n)
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write(f"Read {data}\n")
+                log_file.flush()
+        return data
+
+    def close(self) -> None:
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write("Closing pipe.\n")
+                log_file.flush()
+        self._pipe.close()
+
+    @override
+    def readline(self, limit: int = -1) -> bytes:
+        line = self._pipe.readline(limit)
+        if _debug_log_file is not None:
+            with _debug_log_file.open("a") as log_file:
+                log_file.write(f"Read line {line}\n")
+                log_file.flush()
+        return line
+
+
+def debug_setup_logging(verbose: bool = True, append: bool = False) -> None:
+    set_debug_log_file(
+        str(get_project_root() / "private" / "server1.log"),
+        verbose=verbose,
+        append=append,
+    )
+    set_debug_mode(True)
+    set_debug_verbose(verbose)
+    if (log_file := get_debug_log_file()) is not None:
+        logging.basicConfig(
+            filename=log_file,
+            level=logging.INFO if verbose else logging.DEBUG,
+            filemode="a",
+            format="%(asctime)s %(levelname)s %(name)s %(message)s",
+            force=True,
+        )
+    debug_file_write("=== Typhon Debug Logging set ===\n")

Typhon/Driver/diagnostic.py

@@ -9,8 +9,9 @@ def diag_error_file_position(
     rule: str | None,
     message: str,
 ):
+    # Range is 0-based, but line numbers displayed are 1-based
     return (
-        f"{error_type}: {file_path}:{position.start.line}:{position.start.column}{rule if rule else ''}\n"
+        f"{error_type}: {file_path}:{position.start.line + 1}:{position.start.column + 1}{rule if rule else ''}\n"
         f"  {message}"
     )
 
@@ -22,8 +23,8 @@ def positioned_source_code(
     result = ""
     len_in_digit = len(str(range_in_source.end.line)) + 1
     for line_num in range(range_in_source.start.line, range_in_source.end.line + 1):
-        if line_num >= 1 and line_num <= len(source_lines):
-            result += f"    {line_num:<{len_in_digit}}|  {source_lines[line_num - 1]}\n"
+        if line_num >= 0 and line_num < len(source_lines):
+            result += f"    {line_num + 1:<{len_in_digit}}|  {source_lines[line_num]}\n"
             if (
                 range_in_source.start.line == range_in_source.end.line
                 and line_num == range_in_source.start.line

Typhon/Driver/language_server.py

@@ -0,0 +1,25 @@
+from ..LanguageServer import server
+from ..Driver.debugging import (
+    is_debug_mode,
+    BinaryIOLogger,
+    set_debug_log_file,
+    debug_print,
+    get_debug_log_file,
+    set_debug_verbose,
+    debug_setup_logging,
+)
+import sys
+import logging
+
+
+def language_server():
+    """
+    Start the Typhon Language Server.
+    """
+    server.start_io(
+        stdin=BinaryIOLogger(sys.stdin.buffer),
+        stdout=BinaryIOLogger(sys.stdout.buffer),
+    )
+
+    # TODO: Support TCP Mode?
+    # server.start_tcp("127.0.0.1", 8080)

Typhon/Driver/run.py

@@ -92,7 +92,7 @@ def run_directory(source_dir: Path, capture_output: bool, *args: str) -> RunResu
     # Set up environment with modified PYTHONPATH
     orig_pythonpath = os.environ.get("PYTHONPATH", "")
     if orig_pythonpath:
-        orig_pythonpath = f":{orig_pythonpath}"
+        orig_pythonpath = f"{os.pathsep}{orig_pythonpath}"
     subprocess_env = {
         **dict(os.environ),
         # Override PYTHONPATH to include temp_output_dir

Typhon/Driver/translate.py

@@ -5,21 +5,23 @@ from dataclasses import dataclass
 from ..Grammar.parser import parse_file
 from ..Grammar.syntax_errors import (
     diag_errors,
-    TyphonSyntaxError,
+    TyphonTransformSyntaxError,
     TyphonSyntaxErrorList,
 )
+from ..Grammar.unparse_custom import unparse_custom
 from .utils import (
     shorthand,
     TYPHON_EXT,
     copy_type,
     default_output_dir,
     canonicalize_path,
+    mkdir_and_setup_init_py,
 )
 from ..Transform.transform import transform
 from .debugging import is_debug_mode, debug_print, is_debug_verbose
 from ..Driver.type_check import run_type_check, TypeCheckResult
 from ..SourceMap import SourceMap
-from ..SourceMap.ast_match_based_map import map_from_transformed_ast
+from ..SourceMap.ast_match_based_map import map_from_translated_ast
 
 
 @dataclass
@@ -27,7 +29,9 @@ class TranslateResult:
     source_path_canonical: str
     output_path_canonical: str
     source_map: SourceMap | None
-    syntax_error: SyntaxError | TyphonSyntaxError | TyphonSyntaxErrorList | None
+    syntax_error: (
+        SyntaxError | TyphonTransformSyntaxError | TyphonSyntaxErrorList | None
+    )
 
 
 def translate_file(source: Path, output: Path) -> TranslateResult:
@@ -35,7 +39,7 @@ def translate_file(source: Path, output: Path) -> TranslateResult:
     try:
         ast_tree = parse_file(source.as_posix(), verbose=is_debug_verbose())
         transform(ast_tree)
-    except (SyntaxError, TyphonSyntaxError, TyphonSyntaxErrorList) as e:
+    except (SyntaxError, TyphonTransformSyntaxError, TyphonSyntaxErrorList) as e:
         debug_print(f"Error parsing file {source}: {e}")
         return TranslateResult(
             source_path_canonical=canonicalize_path(source),
@@ -43,10 +47,14 @@ def translate_file(source: Path, output: Path) -> TranslateResult:
             source_map=None,
             syntax_error=e,
         )
-    translated_code = ast.unparse(ast_tree)
+    translated_code = unparse_custom(ast_tree)
     source_code = source.read_text(encoding="utf-8")
-    mapping = map_from_transformed_ast(
-        ast_tree, ast.parse(translated_code), source_code, source.as_posix()
+    mapping = map_from_translated_ast(
+        ast_tree,
+        ast.parse(translated_code),
+        source_code,
+        source.as_posix(),
+        translated_code,
     )
     output.write_text(translated_code)
     return TranslateResult(
@@ -95,10 +103,7 @@ def translate_directory(
         output_path = module_output_dir / (source.stem + ".py")
         file_result = translate_file(source, output_path)
         result[source] = file_result
-    if not (module_output_dir / "__init__.py").exists():
-        (module_output_dir / "__init__.py").write_text(
-            "# Init file for Typhon module\n", "utf-8"
-        )
+    mkdir_and_setup_init_py(module_output_dir)
     for subdir in source_dir.iterdir():
         if subdir.is_dir():
             sub_output_dir = module_output_dir / subdir.name

Typhon/Driver/utils.py

@@ -4,6 +4,8 @@ import os
 
 
 TYPHON_EXT = ".typh"
+TYPHON_TEMP_DIR = ".typhon"
+TYPHON_SERVER_TEMP_DIR = ".typhon-server"
 
 
 def shorthand[T](
@@ -29,7 +31,19 @@ def shorthand[T](
 
 
 def default_output_dir(source: str) -> Path:
-    return Path(source).parent / ".typhon"
+    return Path(source).parent / TYPHON_TEMP_DIR
+
+
+def output_dir_for_workspace(workspace: Path) -> Path:
+    return workspace / TYPHON_SERVER_TEMP_DIR
+
+
+def default_server_output_dir(source: str) -> Path:
+    return Path(source).parent / TYPHON_SERVER_TEMP_DIR
+
+
+def output_dir_for_server_workspace(workspace: Path) -> Path:
+    return workspace / TYPHON_SERVER_TEMP_DIR
 
 
 def prepare_default_output_file(source: Path) -> Path:
@@ -39,6 +53,21 @@ def prepare_default_output_file(source: Path) -> Path:
     return output_file
 
 
+def prepare_default_server_output_file(source: Path) -> Path:
+    temp_output_dir = default_server_output_dir(source.as_posix())
+    temp_output_dir.mkdir(exist_ok=True)
+    output_file = temp_output_dir / (source.stem + ".py")
+    return output_file
+
+
+def mkdir_and_setup_init_py(dir: Path) -> None:
+    if not dir.exists():
+        dir.mkdir(parents=True, exist_ok=True)
+    init_file = dir / "__init__.py"
+    if not init_file.exists():
+        init_file.write_text("# Init file_for Typhon module.", encoding="utf-8")
+
+
 def copy_type[**P, T](
     _: Callable[P, T],
 ) -> Callable[[Callable[..., T]], Callable[P, T]]:
@@ -52,3 +81,12 @@ def copy_type[**P, T](
 # For windows, convert all to lower case and resolve.
 def canonicalize_path(path: Path) -> str:
     return Path(os.path.normcase(str(path))).resolve().as_posix()
+
+
+def get_project_root() -> Path:
+    current = Path(__file__).resolve()
+    for _ in range(10):
+        if (current / "pyproject.toml").exists():
+            return current
+        current = current.parent
+    raise FileNotFoundError("Could not find project root with pyproject.toml")