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

Typhon/Transform/transform.py

@@ -13,34 +13,38 @@ from .if_while_let import if_while_let_transform
 from .comprehension_to_function import comprehension_to_function
 from .placeholder_to_function import placeholder_to_func
 from .record_to_dataclass import record_to_dataclass
+from .extended_patterns import extended_protocol
 
 from ..Grammar.syntax_errors import raise_from_module_syntax_errors
+from ..Grammar.unparse_custom import unparse_custom
 
 
 def transform(mod: ast.Module):
     check_forbidden_statements(mod)
     record_to_dataclass(mod)
-    debug_verbose_print(f"After record_to_dataclass:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After record_to_dataclass:\n{unparse_custom(mod)}\n")
+    extended_protocol(mod)
+    debug_verbose_print(f"After extended_protocol:\n{unparse_custom(mod)}\n")
     inline_statement_block_capture(mod)
-    debug_print(f"After inline_statement_block_capture:\n{ast.unparse(mod)}\n")
+    debug_print(f"After inline_statement_block_capture:\n{unparse_custom(mod)}\n")
     if_while_let_transform(mod)
-    debug_verbose_print(f"After if_while_let_transform:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After if_while_let_transform:\n{unparse_custom(mod)}\n")
     insert_self_to_method(mod)
-    debug_verbose_print(f"After insert_self_to_method:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After insert_self_to_method:\n{unparse_custom(mod)}\n")
     comprehension_to_function(mod)
-    debug_verbose_print(f"After comprehension_to_function:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After comprehension_to_function:\n{unparse_custom(mod)}\n")
     func_literal_to_def(mod)
-    debug_print(f"After func_literal_to_def:\n{ast.unparse(mod)}\n")
+    debug_print(f"After func_literal_to_def:\n{unparse_custom(mod)}\n")
     scope_check_rename(mod)
-    debug_print(f"After scope_check_rename:\n{ast.unparse(mod)}\n")
+    debug_print(f"After scope_check_rename:\n{unparse_custom(mod)}\n")
     placeholder_to_func(mod)
-    debug_print(f"After placeholder_to_func:\n{ast.unparse(mod)}\n")
+    debug_print(f"After placeholder_to_func:\n{unparse_custom(mod)}\n")
     optional_to_checked(mod)
-    debug_verbose_print(f"After optional_to_checked:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After optional_to_checked:\n{unparse_custom(mod)}\n")
     type_annotation_check_expand(mod)
-    debug_verbose_print(f"After type_annotation_check_expand:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After type_annotation_check_expand:\n{unparse_custom(mod)}\n")
     type_abbrev_desugar(mod)
-    debug_verbose_print(f"After func_type_to_protocol:\n{ast.unparse(mod)}\n")
+    debug_verbose_print(f"After func_type_to_protocol:\n{unparse_custom(mod)}\n")
     const_member_to_final(mod)
-    debug_print(f"After transform:\n{ast.unparse(mod)}\n")
+    debug_print(f"After transform:\n{unparse_custom(mod)}\n")
     raise_from_module_syntax_errors(mod)

Typhon/Transform/type_abbrev_desugar.py

@@ -12,12 +12,11 @@ from ..Grammar.typhon_ast import (
     is_typing_expression,
     is_optional_question,
 )
-from ..Grammar.syntax_errors import (
-    raise_type_annotation_error,
-    try_handle_syntax_error_or,
-)
 from .visitor import TyphonASTVisitor, TyphonASTTransformer
-from .utils import add_import_for_protocol, get_insert_point_for_class
+from .utils.imports import (
+    get_insert_point_for_class,
+    get_protocol,
+)
 from ..Driver.debugging import debug_print, debug_verbose_print
 
 
@@ -34,7 +33,7 @@ class _GatherArrowType(TyphonASTVisitor):
 
 
 def _protocol_for_function_type(
-    func_type: FunctionType, arrow_type_name: str, protocol_name: str
+    mod: ast.Module, func_type: FunctionType, arrow_type_name: str
 ) -> ast.ClassDef:
     func_type.id = arrow_type_name
     args = get_args_of_function_type(func_type)
@@ -77,9 +76,7 @@ def _protocol_for_function_type(
     )
     protocol_def = ast.ClassDef(
         name=arrow_type_name,
-        bases=[
-            ast.Name(id=protocol_name, ctx=ast.Load()),
-        ],
+        bases=[get_protocol(mod, ctx=ast.Load(), **get_empty_pos_attributes())],
         keywords=[],
         body=[func_def],
         decorator_list=[],
@@ -92,18 +89,18 @@ def _protocol_for_function_type(
 
 
 def _add_protocols(
-    mod: ast.Module, func_types: list[tuple[FunctionType, str]], protocol_name: str
+    mod: ast.Module, func_types: list[tuple[FunctionType, str]]
 ) -> dict[FunctionType, ast.ClassDef]:
     result: dict[FunctionType, ast.ClassDef] = {}
+    # Ensure protocol is imported before classes.
+    get_protocol(mod, ctx=ast.Load(), **get_empty_pos_attributes())
     # Insert after imports.
     insert_point = get_insert_point_for_class(mod)
     for func_type, arrow_type_name in func_types:
         debug_print(
             f"Adding protocol for function type: {func_type.__dict__} as {arrow_type_name}"
         )
-        protocol_def = _protocol_for_function_type(
-            func_type, arrow_type_name, protocol_name
-        )
+        protocol_def = _protocol_for_function_type(mod, func_type, arrow_type_name)
         result[func_type] = protocol_def
         mod.body.insert(insert_point, protocol_def)
         insert_point += 1
@@ -193,8 +190,7 @@ def type_abbrev_desugar(mod: ast.Module):
     gatherer = _GatherArrowType(mod)
     gatherer.run()
     if gatherer.func_types:
-        protocol_name = add_import_for_protocol(mod)
-        _add_protocols(mod, gatherer.func_types, protocol_name)
+        _add_protocols(mod, gatherer.func_types)
     # Run optional question first, as it is represented as Tuple nodes.
     _OptionalQuestionTransformer(mod).run()
     _TupleListTransformer(mod).run()

Typhon/Transform/type_annotation_check_expand.py

@@ -13,7 +13,7 @@ from ..Grammar.typhon_ast import (
 from ..Grammar.syntax_errors import (
     raise_type_annotation_error,
     handle_syntax_error,
-    TyphonSyntaxError,
+    TyphonTransformSyntaxError,
 )
 from .visitor import TyphonASTTransformer, TyphonASTVisitor, flat_append
 from ..Driver.debugging import debug_print, debug_verbose_print
@@ -50,7 +50,7 @@ def _expand_target_annotation(
             result.append(new_assign)
             copy_is_let_var(orig_node, new_assign)
         return result
-    except TyphonSyntaxError as e:
+    except TyphonTransformSyntaxError as e:
         handle_syntax_error(module, e)
         return []
 

Typhon/Transform/utils/imports.py

@@ -0,0 +1,83 @@
+from ...Grammar.typhon_ast import (
+    PosAttributes,
+    add_import_alias_top,
+    is_case_irrefutable,
+    get_pos_attributes,
+    pos_attribute_to_range,
+    set_is_internal_name,
+    set_is_var,
+)
+from ..name_generator import (
+    get_protocol_name,
+    get_final_name,
+    get_dataclass_name,
+    get_runtime_checkable_name,
+)
+import ast
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Protocol, Iterable, Final, Unpack
+
+
+def _add_import_for_protocol(mod: ast.Module):
+    name = get_protocol_name()
+    add_import_alias_top(mod, "typing", "Protocol", name)
+    return name
+
+
+def get_protocol(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    protocol_name = _add_import_for_protocol(mod)
+    return set_is_internal_name(ast.Name(id=protocol_name, ctx=ctx, **kwargs))
+
+
+def add_import_for_final(mod: ast.Module):
+    name = get_final_name()
+    add_import_alias_top(mod, "typing", "Final", name)
+    return name
+
+
+def get_final(ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]) -> ast.Name:
+    final_name = get_final_name()
+    return set_is_internal_name(ast.Name(id=final_name, ctx=ctx, **kwargs))
+
+
+def add_import_get_final(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    final_name = add_import_for_final(mod)
+    return set_is_internal_name(ast.Name(id=final_name, ctx=ctx, **kwargs))
+
+
+def _add_import_for_dataclass(mod: ast.Module):
+    name = get_dataclass_name()
+    add_import_alias_top(mod, "dataclasses", "dataclass", name)
+    return name
+
+
+def get_dataclass(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    dataclass_name = _add_import_for_dataclass(mod)
+    return set_is_internal_name(ast.Name(id=dataclass_name, ctx=ctx, **kwargs))
+
+
+def _add_import_for_runtime_checkable(mod: ast.Module):
+    name = get_runtime_checkable_name()
+    add_import_alias_top(mod, "typing", "runtime_checkable", name)
+    return name
+
+
+def get_runtime_checkable(
+    mod: ast.Module, ctx: ast.expr_context, **kwargs: Unpack[PosAttributes]
+) -> ast.Name:
+    runtime_checkable_name = _add_import_for_runtime_checkable(mod)
+    return set_is_internal_name(ast.Name(id=runtime_checkable_name, ctx=ctx, **kwargs))
+
+
+def get_insert_point_for_class(module: ast.Module) -> int:
+    for index, stmt in enumerate(module.body):
+        if not isinstance(stmt, (ast.Import, ast.ImportFrom)):
+            return index
+    return len(module.body)

Typhon/Transform/{utils.py → utils/jump_away.py}

@@ -1,46 +1,9 @@
-from ..Grammar.typhon_ast import add_import_alias_top, is_case_irrefutable
-from .name_generator import (
-    get_protocol_name,
-    get_final_name,
-    get_dataclass_name,
-    get_runtime_checkable_name,
-)
+from ...Grammar.typhon_ast import is_case_irrefutable
 import ast
 from contextlib import contextmanager
 from dataclasses import dataclass
 
 
-def add_import_for_protocol(mod: ast.Module):
-    name = get_protocol_name()
-    add_import_alias_top(mod, "typing", "Protocol", name)
-    return name
-
-
-def add_import_for_final(mod: ast.Module):
-    name = get_final_name()
-    add_import_alias_top(mod, "typing", "Final", name)
-    return name
-
-
-def add_import_for_dataclass(mod: ast.Module):
-    name = get_dataclass_name()
-    add_import_alias_top(mod, "dataclasses", "dataclass", name)
-    return name
-
-
-def add_import_for_runtime_checkable(mod: ast.Module):
-    name = get_runtime_checkable_name()
-    add_import_alias_top(mod, "typing", "runtime_checkable", name)
-    return name
-
-
-def get_insert_point_for_class(module: ast.Module) -> int:
-    for index, stmt in enumerate(module.body):
-        if not isinstance(stmt, (ast.Import, ast.ImportFrom)):
-            return index
-    return len(module.body)
-
-
 @dataclass
 class _Loop:
     node: ast.AST
@@ -117,6 +80,7 @@ class _JumpAwayVisitor(ast.NodeVisitor):
         return jump_away
 
     def visit_Match(self, node: ast.Match):
+        # Check that all cases jump away, and at least one is irrefutable.
         jump_away = True
         found_irrefutable = False
         for case in node.cases:

Typhon/Transform/utils/make_class.py

@@ -0,0 +1,135 @@
+from ...Driver.debugging import debug_print
+from ...Grammar.typhon_ast import (
+    get_pos_attributes,
+    pos_attribute_to_range,
+    set_is_var,
+    PosAttributes,
+)
+import ast
+from typing import Protocol, Iterable, Final
+from .imports import (
+    get_dataclass,
+    add_import_get_final,
+    get_protocol,
+    get_runtime_checkable,
+)
+
+
+class NameAndAnnotation(Protocol):
+    name: Final[ast.Name]
+    annotation: Final[ast.expr]
+
+
+def _class_contents_for_fields(
+    fields: Iterable[NameAndAnnotation],
+    final_imported_name: ast.Name,
+) -> list[ast.stmt]:
+    result: list[ast.stmt] = []
+    for field in fields:
+        name = field.name
+        if field.annotation:
+            # Currently annotation is always Final[...] for record fields.
+            annotation = ast.Subscript(
+                value=final_imported_name,
+                slice=field.annotation,
+                ctx=ast.Load(),
+                **get_pos_attributes(name),
+            )
+        else:
+            annotation = final_imported_name
+        ann_assign = ast.AnnAssign(
+            target=ast.Name(id=name.id, ctx=ast.Store(), **get_pos_attributes(name)),
+            annotation=annotation,
+            value=None,
+            simple=1,
+            **get_pos_attributes(name),
+        )
+        # "var" because dataclass is frozen, "Final" is not required.
+        set_is_var(ann_assign)
+        result.append(ann_assign)
+    return result
+
+
+def _type_vars_for_fields(
+    pos: PosAttributes, type_variables: list[str]
+) -> list[ast.type_param]:
+    type_params: list[ast.type_param] = []
+    for tv in type_variables:
+        type_params.append(ast.TypeVar(name=tv, **pos_attribute_to_range(pos)))
+    return type_params
+
+
+def make_protocol_definition(
+    mod: ast.Module,
+    class_name: str,
+    type_variables: list[str],
+    fields: Iterable[NameAndAnnotation],
+    pos: PosAttributes,
+) -> ast.ClassDef:
+    protocol_imported_name = get_protocol(mod, ctx=ast.Load(), **pos)
+    runtime_checkable_imported_name = get_runtime_checkable(mod, ctx=ast.Load(), **pos)
+    final_imported_name = add_import_get_final(mod, ctx=ast.Load(), **pos)
+    result = ast.ClassDef(
+        name=class_name,
+        type_params=_type_vars_for_fields(pos, type_variables),
+        bases=[protocol_imported_name],
+        keywords=[],
+        # Currently all fields are Final.
+        body=_class_contents_for_fields(fields, final_imported_name),
+        decorator_list=[runtime_checkable_imported_name],
+        **pos,
+    )
+    return result
+
+
+def _dataclass_decorator(
+    dataclass_imported_name: ast.Name, repr: bool, pos: PosAttributes
+) -> ast.expr:
+    return ast.Call(
+        func=dataclass_imported_name,
+        args=[],
+        keywords=[
+            ast.keyword(arg="frozen", value=ast.Constant(value=True)),
+            ast.keyword(arg="repr", value=ast.Constant(value=repr)),
+            ast.keyword(arg="unsafe_hash", value=ast.Constant(value=True)),
+            ast.keyword(arg="kw_only", value=ast.Constant(value=True)),
+        ],
+    )
+
+
+def make_dataclass_definition(
+    mod: ast.Module,
+    class_name: str,
+    type_variables: list[str],
+    fields: Iterable[NameAndAnnotation],
+    pos: PosAttributes,
+) -> ast.ClassDef:
+    dataclass_imported_name = get_dataclass(mod, ctx=ast.Load(), **pos)
+    final_imported_name = add_import_get_final(mod, ctx=ast.Load(), **pos)
+    result = ast.ClassDef(
+        name=class_name,
+        type_params=_type_vars_for_fields(pos, type_variables),
+        bases=[],
+        keywords=[],
+        body=_class_contents_for_fields(fields, final_imported_name),
+        decorator_list=[
+            _dataclass_decorator(dataclass_imported_name, repr=False, pos=pos)
+        ],
+        **pos,
+    )
+    return result
+
+
+def make_dataclass_protocol_definition(
+    mod: ast.Module,
+    class_name: str,
+    type_variables: list[str],
+    fields: Iterable[NameAndAnnotation],
+    pos: PosAttributes,
+) -> ast.ClassDef:
+    dataclass_imported_name = get_dataclass(mod, ctx=ast.Load(), **pos)
+    result = make_protocol_definition(mod, class_name, type_variables, fields, pos)
+    result.decorator_list.append(
+        _dataclass_decorator(dataclass_imported_name, repr=True, pos=pos)
+    )
+    return result

Typhon/Transform/visitor.py

@@ -276,6 +276,31 @@ class _ErrorHandlingMixin:
         )
 
 
+class TyphonASTRawVisitor(
+    ast.NodeVisitor,
+    _TyphonExtendedNodeTransformerMixin,
+):
+    def visit_PossiblyAnnotatedNode(self, node: ast.AST):
+        self._visit_Possibly_Annotated_Node(node, self, False)
+
+    @override
+    def visit(self, node: ast.AST):
+        return self._visit(node, self, super().visit)
+
+    @override
+    def generic_visit(self, node: ast.AST):
+        # visit() calls _visit() but generic_visit() does not. So we need to dispatch here too.
+        if isinstance(node, ast.Name):
+            if is_function_literal(node):
+                return self._visit_FunctionLiteral(node, self, False)
+            elif is_function_type(node):
+                return self._visit_FunctionType(node, self, False)
+            elif is_control_comprehension(node):
+                return self._visit_ControlComprehension(node, self, False)
+        self.visit_PossiblyAnnotatedNode(node)
+        return super().generic_visit(node)
+
+
 class TyphonASTVisitor(
     ast.NodeVisitor,
     _ScopeManagerMixin,

Typhon/Typing/pyrefly.py

@@ -0,0 +1,145 @@
+import sys
+from pathlib import Path
+import subprocess
+import toml
+from ..Driver.debugging import debug_print
+from typing import Literal, cast, Any
+import json
+from .result_diagnostic import Severity, Diagnostic, TypeCheckResult
+from ..SourceMap.datatype import Range, Pos
+
+# https://docs.basedpyrefly.com/dev/configuration/config-files/
+type TypeCheckLevel = Literal[
+    "off",
+    "basic",
+    "strict",
+    "all",
+    "translate",  # Default for Typhon translation
+    "script",  # Default for Typhon scripts
+]
+translate_config = {
+    "typeCheckingMode": "strict",
+    "reportUnusedExpression": "warning",
+    "reportUnusedClass": "warning",
+    "reportUnusedImport": "warning",
+    "reportUnusedFunction": "warning",
+    "reportUnusedVariable": "warning",
+    "reportUnusedCallResult": "warning",
+    "reportUnnecessaryIsInstance": "warning",
+    "reportUnnecessaryCast": "warning",
+    # "reportUnnecessaryComparison": "warning", # To check type of patterns
+    "reportUnnecessaryContains": "warning",
+    "reportDeprecated": "warning",
+}
+script_config = {
+    "typeCheckingMode": "strict",
+    "reportUnusedExpression": "none",
+    "reportUnusedClass": "none",
+    "reportUnusedImport": "none",
+    "reportUnusedFunction": "none",
+    "reportUnusedVariable": "none",
+    "reportUnusedCallResult": "none",
+    "reportUnnecessaryIsInstance": "none",
+    "reportUnnecessaryCast": "none",
+    # "reportUnnecessaryComparison": "none",  # To check type of patterns
+    "reportUnnecessaryContains": "none",
+    "reportDeprecated": "none",
+}
+
+
+def write_pyrefly_config(
+    output_dir: Path, level: TypeCheckLevel = "translate", overwrite: bool = False
+) -> str:
+    config = {
+        "include": ["**/*.py"],
+        "exclude": ["**/__pycache__"],
+        "typeCheckingMode": "off",
+    }
+    if level == "translate":
+        config.update(translate_config)
+    elif level == "script":
+        config.update(script_config)
+    elif level == "basic":
+        config["typeCheckingMode"] = "basic"
+    elif level == "strict":
+        config["typeCheckingMode"] = "strict"
+    elif level == "all":
+        config["typeCheckingMode"] = "all"
+    else:
+        raise ValueError(f"Unknown type check level: {level}")
+    config_path = output_dir / "pyreflyconfig.json"
+    if not overwrite and config_path.exists():
+        debug_print(
+            f"Config file already exists at {config_path}. Use overwrite=True to replace."
+        )
+        return str(config_path)
+    toml_str = toml.dumps(config)
+    with open(config_path, "w") as f:
+        f.write(toml_str)
+    debug_print(f"Generated pyrefly config at {config_path}")
+    return str(config_path)
+
+
+def _try_read_attr[T](d: Any, attr: str, default: T) -> T:
+    result = d.get(attr, default)
+    return cast(T, result)
+
+
+def _parse_pos_range(pos: Any) -> Range:
+    start = _try_read_attr(pos, "start", {})
+    end = _try_read_attr(pos, "end", {})
+    return Range(
+        start=Pos(line=start.get("line", 0), column=start.get("character", 0)),
+        end=Pos(line=end.get("line", 0), column=end.get("character", 0)),
+    )
+
+
+def _parse_diagnostic(diag: Any) -> Diagnostic:
+    return Diagnostic(
+        file_path=_try_read_attr(diag, "file", ""),
+        severity=Severity[_try_read_attr(diag, "severity", "INFO").upper()],
+        message=_try_read_attr(diag, "message", ""),
+        pos=_parse_pos_range(diag["range"]),
+        rule=_try_read_attr(diag, "rule", ""),
+    )
+
+
+def parse_json_output(output: str, returncode: int, stderr: str) -> TypeCheckResult:
+    data = json.loads(output)
+    diagnostics = [
+        _parse_diagnostic(diag) for diag in data.get("generalDiagnostics", [])
+    ]
+    summary = _try_read_attr(data, "summary", {})
+    return TypeCheckResult(
+        returncode=returncode,
+        stderr=stderr,
+        files_analyzed=_try_read_attr(summary, "filesAnalyzed", 0),
+        num_errors=_try_read_attr(summary, "errorCount", 0),
+        num_warnings=_try_read_attr(summary, "warningCount", 0),
+        num_info=_try_read_attr(summary, "informationCount", 0),
+        time_in_sec=_try_read_attr(summary, "timeInSec", 0.0),
+        diagnostics=diagnostics,
+    )
+
+
+def run_pyrefly(
+    py_file_or_dir: Path, level: TypeCheckLevel = "translate"
+) -> TypeCheckResult:
+    output = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "pyrefly",
+            "check",
+            "--output-format",
+            "json",
+            str(py_file_or_dir),
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        shell=False,
+    )
+    result = parse_json_output(
+        output.stdout.decode(), output.returncode, output.stderr.decode()
+    )
+    return result