cinderx 2026.1.16.2__cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

cinderx/compiler/static/util.py

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+from __future__ import annotations
+
+import ast
+import sys
+from typing import Callable, Mapping
+
+COMPARE_OPS: Mapping[type[ast.cmpop], Callable[[object, object], bool]] = {
+    ast.Gt: lambda a, b: a > b,
+    ast.GtE: lambda a, b: a >= b,
+    ast.Lt: lambda a, b: a < b,
+    ast.LtE: lambda a, b: a <= b,
+    ast.Eq: lambda a, b: a == b,
+    ast.NotEq: lambda a, b: a != b,
+    ast.In: lambda a, b: a in b,
+    ast.Is: lambda a, b: a is b,
+    ast.IsNot: lambda a, b: a is not b,
+}
+
+
+def make_qualname(parent_qualname: str | None, name: str) -> str:
+    if parent_qualname is None:
+        return name
+    return f"{parent_qualname}.{name}"
+
+
+def _is_sys_hexversion_attr_load(node: ast.expr) -> bool:
+    if isinstance(node, ast.Attribute):
+        container = node.value
+        if (
+            isinstance(container, ast.Name)
+            and container.id == "sys"
+            and isinstance(node.ctx, ast.Load)
+            and node.attr == "hexversion"
+        ):
+            return True
+    return False
+
+
+def _get_const_int(node: ast.expr) -> int | None:
+    if isinstance(node, ast.Constant):
+        value = node.value
+        return value if isinstance(value, int) else None
+
+
+def sys_hexversion_check(
+    node: ast.If,
+) -> bool | None:
+    """
+    A helper function, the result of this is used to determine whether
+    we need to skip visiting dead code gated by sys.hexversion checks.
+    """
+    test_node = node.test
+    if isinstance(test_node, ast.Compare):
+        if len(test_node.comparators) != 1:
+            return None
+
+        assert len(test_node.ops) == 1
+
+        left = test_node.left
+        right = test_node.comparators[0]
+        op = test_node.ops[0]
+
+        if type(op) in (ast.In, ast.Is, ast.IsNot):
+            return None
+
+        if _is_sys_hexversion_attr_load(left):
+            left_value = sys.hexversion
+            right_value = _get_const_int(right)
+        elif _is_sys_hexversion_attr_load(right):
+            left_value = _get_const_int(left)
+            right_value = sys.hexversion
+        else:
+            return None
+
+        if left_value is None or right_value is None:
+            return None
+
+        return COMPARE_OPS[type(op)](left_value, right_value)

cinderx/compiler/static/visitor.py

@@ -0,0 +1,91 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+from __future__ import annotations
+
+from ast import AST
+from contextlib import contextmanager, nullcontext
+from typing import ContextManager, Generator, Generic, Sequence, TYPE_CHECKING, TypeVar
+
+from ..visitor import ASTVisitor
+
+if TYPE_CHECKING:
+    from ..errors import ErrorSink
+    from .compiler import Compiler
+    from .module_table import ModuleTable
+    from .types import TypeEnvironment
+
+
+TVisitRet = TypeVar("TVisitRet", covariant=True)
+
+
+class GenericVisitor(ASTVisitor, Generic[TVisitRet]):
+    def __init__(self, module: ModuleTable) -> None:
+        super().__init__()
+        self.module = module
+        self.module_name: str = module.name
+        self.filename: str = module.filename
+        self.compiler: Compiler = module.compiler
+        self.error_sink: ErrorSink = module.compiler.error_sink
+        self.type_env: TypeEnvironment = module.compiler.type_env
+        # the qualname that should be the "requester" of types used (for dep tracking)
+        self._context_qualname: str = ""
+        # if true, all deps tracked in visiting should be considered decl deps
+        self.force_decl_deps: bool = False
+
+    @property
+    def context_qualname(self) -> str:
+        return self._context_qualname
+
+    @contextmanager
+    def temporary_context_qualname(
+        self, qualname: str | None, force_decl: bool = False
+    ) -> Generator[None, None, None]:
+        old_qualname = self._context_qualname
+        self._context_qualname = qualname or ""
+        old_decl = self.force_decl_deps
+        self.force_decl_deps = force_decl
+        try:
+            yield
+        finally:
+            self._context_qualname = old_qualname
+            self.force_decl_deps = old_decl
+
+    def record_dependency(self, source: tuple[str, str]) -> None:
+        self.module.record_dependency(
+            self.context_qualname, source, force_decl=self.force_decl_deps
+        )
+
+    def visit(self, node: AST, *args: object) -> TVisitRet:
+        # if we have a sequence of nodes, don't catch TypedSyntaxError here;
+        # walk_list will call us back with each individual node in turn and we
+        # can catch errors and add node info then.
+        ctx = self.error_context(node) if isinstance(node, AST) else nullcontext()
+        with ctx:
+            if not args:
+                # pyre-ignore: ASTVisitor is not generic yet, can't assert the result is
+                # TVisitRet.
+                return super().visit(node)
+            # pyre-ignore: ASTVisitor is not generic yet, can't assert the result is
+            # TVisitRet.
+            return super().visit(node, *args)
+
+    def syntax_error(self, msg: str, node: AST) -> None:
+        return self.error_sink.syntax_error(msg, self.filename, node)
+
+    def perf_warning(self, msg: str, node: AST) -> None:
+        return self.error_sink.perf_warning(msg, self.filename, node)
+
+    def error_context(self, node: AST | None) -> ContextManager[None]:
+        if node is None:
+            return nullcontext()
+        return self.error_sink.error_context(self.filename, node)
+
+    @contextmanager
+    def temporary_error_sink(self, sink: ErrorSink) -> Generator[None, None, None]:
+        orig_sink = self.error_sink
+        self.error_sink = sink
+        try:
+            yield
+        finally:
+            self.error_sink = orig_sink

cinderx/compiler/strict/__init__.py

@@ -0,0 +1,69 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# pyre-strict
+
+from __future__ import annotations
+
+import ast
+import builtins
+import sys
+from types import CodeType
+from typing import Any
+
+from ..pyassem import (
+    PyFlowGraph312,
+    PyFlowGraph314,
+    PyFlowGraph315,
+    PyFlowGraphCinder310,
+)
+from ..pycodegen import (
+    CinderCodeGenerator310,
+    CinderCodeGenerator312,
+    CinderCodeGenerator314,
+    CinderCodeGenerator315,
+)
+from .code_gen_base import StrictCodeGenBase
+
+
+# Unused but still present until we remove it from IGSRV
+enable_strict_features: bool = True
+
+
+class StrictCodeGenerator310(StrictCodeGenBase, CinderCodeGenerator310):
+    flow_graph = PyFlowGraphCinder310
+
+
+class StrictCodeGenerator312(StrictCodeGenBase, CinderCodeGenerator312):
+    flow_graph = PyFlowGraph312
+
+
+class StrictCodeGenerator314(StrictCodeGenerator312, CinderCodeGenerator314):
+    flow_graph = PyFlowGraph314
+
+
+class StrictCodeGenerator315(StrictCodeGenerator312, CinderCodeGenerator315):
+    flow_graph = PyFlowGraph315
+
+
+def strict_compile(
+    name: str,
+    filename: str,
+    tree: ast.Module,
+    source: str | bytes,
+    optimize: int = 0,
+    builtins: dict[str, Any] = builtins.__dict__,
+) -> CodeType:
+    code_gen = StrictCodeGenerator.make_code_gen(
+        name, tree, filename, source, flags=0, optimize=optimize, builtins=builtins
+    )
+    return code_gen.getCode()
+
+
+if sys.version_info >= (3, 15):
+    StrictCodeGenerator = StrictCodeGenerator315
+elif sys.version_info >= (3, 14):
+    StrictCodeGenerator = StrictCodeGenerator314
+elif sys.version_info >= (3, 12):
+    StrictCodeGenerator = StrictCodeGenerator312
+else:
+    StrictCodeGenerator = StrictCodeGenerator310

cinderx/compiler/strict/class_conflict_checker.py

@@ -0,0 +1,249 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# pyre-strict
+
+from __future__ import annotations
+
+import ast
+from ast import (
+    AnnAssign,
+    Assign,
+    AST,
+    AsyncFunctionDef,
+    Attribute,
+    ClassDef,
+    Delete,
+    ExceptHandler,
+    FunctionDef,
+    Global,
+    Import,
+    ImportFrom,
+    Module,
+    Name,
+)
+from symtable import SymbolTable
+from typing import final, MutableMapping
+
+from ..consts import CO_FUTURE_ANNOTATIONS
+from ..pycodegen import find_futures
+from .common import (
+    get_symbol_map,
+    imported_name,
+    ScopeStack,
+    StrictModuleError,
+    SymbolMap,
+    SymbolScope,
+)
+from .rewriter.rewriter import SymbolVisitor
+
+CLASS_ATTR_CONFLICT_EXCEPTION = "ClassAttributesConflictException"
+
+
+class TransformerScope:
+    def visit_Assign(self, node: Assign) -> None:
+        pass
+
+    def visit_AnnAssign(self, node: AnnAssign) -> None:
+        pass
+
+    def loaded(self, name: str) -> None:
+        pass
+
+    def stored(self, name: str) -> None:
+        pass
+
+
+@final
+class ClassScope(TransformerScope):
+    def __init__(self) -> None:
+        self.instance_fields: set[str] = set()
+        self.class_fields: set[str] = set()
+
+    def visit_AnnAssign(self, node: AnnAssign) -> None:
+        target = node.target
+        if isinstance(target, Name):
+            if node.value is None:
+                self.instance_fields.add(target.id)
+            else:
+                self.class_fields.add(target.id)
+
+    def stored(self, name: str) -> None:
+        self.class_fields.add(name)
+
+
+@final
+class FunctionScope(TransformerScope):
+    def __init__(self, node: FunctionDef, parent: TransformerScope) -> None:
+        self.node = node
+        self.parent = parent
+
+    def visit_AnnAssign(self, node: AnnAssign) -> None:
+        parent = self.parent
+        target = node.target
+        if (
+            isinstance(self.node, FunctionDef)
+            and self.node.name == "__init__"
+            and self.node.args.args
+            and isinstance(parent, ClassScope)
+            and isinstance(target, Attribute)
+        ):
+            self.add_attr_name(target, parent)
+
+    def add_attr_name(self, target: Attribute, parent: ClassScope) -> None:
+        """records self.name = ... when salf matches the 1st parameter"""
+        value = target.value
+        node = self.node
+        if (
+            isinstance(node, FunctionDef)
+            and isinstance(value, Name)
+            and value.id == node.args.args[0].arg
+        ):
+            parent.instance_fields.add(target.attr)
+
+    def visit_Assign(self, node: Assign) -> None:
+        parent = self.parent
+        if (
+            isinstance(self.node, FunctionDef)
+            and self.node.name == "__init__"
+            and isinstance(parent, ClassScope)
+            and self.node.args.args
+        ):
+            for target in node.targets:
+                if not isinstance(target, Attribute):
+                    continue
+                self.add_attr_name(target, parent)
+
+
+@final
+class ClassConflictChecker(SymbolVisitor[object, TransformerScope]):
+    def __init__(
+        self,
+        symbols: SymbolTable,
+        symbol_map: SymbolMap,
+        filename: str,
+        flags: int,
+    ) -> None:
+        super().__init__(
+            ScopeStack(
+                self.make_scope(symbols, None),
+                symbol_map=symbol_map,
+                scope_factory=self.make_scope,
+            ),
+        )
+        self.filename = filename
+        self.flags = flags
+
+    @property
+    def skip_annotations(self) -> bool:
+        return bool(self.flags & CO_FUTURE_ANNOTATIONS)
+
+    def error(self, names: list[str], lineno: int, col: int, filename: str) -> None:
+        MSG: str = "Class member conflicts with instance member: {names}"
+        raise StrictModuleError(MSG.format(names=names), filename, lineno, col)
+
+    def make_scope(
+        self,
+        symtable: SymbolTable,
+        node: AST | None,
+        vars: MutableMapping[str, object] | None = None,
+    ) -> SymbolScope[object, TransformerScope]:
+        if isinstance(node, FunctionDef):
+            data = FunctionScope(node, self.scopes.scopes[-1].scope_data)
+        elif isinstance(node, ClassDef):
+            data = ClassScope()
+        else:
+            data = TransformerScope()
+        return SymbolScope(symtable, data)
+
+    def visit_Name(self, node: Name) -> None:
+        scope = self.scope_for(node.id).scope_data
+        if isinstance(node.ctx, ast.Load):
+            scope.loaded(node.id)
+        else:
+            scope.stored(node.id)
+
+    def visit_ExceptHandler(self, node: ExceptHandler) -> None:
+        self.generic_visit(node)
+        name = node.name
+        if name is not None:
+            self.scope_for(name).scope_data.stored(name)
+
+    def visit_Delete(self, node: Delete) -> None:
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                self.scope_for(target.id).scope_data.stored(target.id)
+
+    def visit_Global(self, node: Global) -> None:
+        if self.scopes.in_class_scope:
+            for name in node.names:
+                if name == "__annotations__":
+                    self.error(
+                        ["__annotations__"], node.lineno, node.col_offset, self.filename
+                    )
+
+    def visit_ClassDef(self, node: ClassDef) -> None:
+        self.visit_Class_Outer(node)
+        class_scope = self.visit_Class_Inner(node).scope_data
+        assert isinstance(class_scope, ClassScope)
+
+        overlap = class_scope.instance_fields.intersection(class_scope.class_fields)
+        if overlap:
+            self.error(list(overlap), node.lineno, node.col_offset, self.filename)
+
+        self.scope_for(node.name).scope_data.stored(node.name)
+
+    def visit_FunctionDef(self, node: FunctionDef) -> None:
+        self.visit_Func_Outer(node)
+
+        func_scope = self.visit_Func_Inner(node)
+
+        self.scopes.current[node.name] = func_scope.scope_data
+
+        self.scope_for(node.name).scope_data.stored(node.name)
+
+    def visit_AsyncFunctionDef(self, node: AsyncFunctionDef) -> None:
+        self.visit_Func_Outer(node)
+
+        self.visit_Func_Inner(node)
+
+        self.scope_for(node.name).scope_data.stored(node.name)
+
+    def visit_Import(self, node: Import) -> None:
+        for name in node.names:
+            self.scope_for(imported_name(name)).scope_data.stored(imported_name(name))
+        return self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ImportFrom) -> None:
+        if node.level == 0 and node.module is not None:
+            for name in node.names:
+                self.scope_for(name.asname or name.name).scope_data.stored(
+                    name.asname or name.name
+                )
+
+    def visit_Assign(self, node: Assign) -> None:
+        self.scopes.scopes[-1].scope_data.visit_Assign(node)
+        self.generic_visit(node)
+
+    def visit_AnnAssign(self, node: AnnAssign) -> None:
+        self.scopes.scopes[-1].scope_data.visit_AnnAssign(node)
+        value = node.value
+        if value is not None:
+            self.visit(node.target)
+            self.visit(value)
+            if not self.skip_annotations:
+                self.visit(node.annotation)
+
+    def visit_arg(self, node: ast.arg) -> None:
+        if not self.skip_annotations:
+            self.generic_visit(node)
+
+
+def check_class_conflict(
+    node: Module,
+    filename: str,
+    symbols: SymbolTable,
+) -> None:
+    symbol_map = get_symbol_map(node, symbols)
+    flags = find_futures(0, node)
+    visitor = ClassConflictChecker(symbols, symbol_map, filename=filename, flags=flags)
+    visitor.visit(node)