cinderx 2026.1.16.2__cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

cinderx/compiler/future.py

@@ -0,0 +1,91 @@
+# Portions copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+"""Parser for future statements"""
+
+import ast
+
+from .visitor import ASTVisitor
+
+
+class FutureParser(ASTVisitor):
+    features = (
+        "nested_scopes",
+        "generators",
+        "division",
+        "absolute_import",
+        "with_statement",
+        "print_function",
+        "unicode_literals",
+        "generator_stop",
+        "barry_as_FLUFL",
+        "annotations",
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.valid: set[ast.ImportFrom] = set()
+        self.found_features: set[str] = set()
+        self.possible_docstring = True
+
+    def visitModule(self, node: ast.Module) -> None:
+        for s in node.body:
+            if (
+                self.possible_docstring
+                and isinstance(s, ast.Expr)
+                and isinstance(s.value, ast.Constant)
+                and isinstance(s.value.value, str)
+            ):
+                self.possible_docstring = False
+                continue
+            # no docstring after first statement
+            self.possible_docstring = False
+            if not self.check_stmt(s):
+                break
+
+    def check_stmt(self, stmt: ast.stmt) -> bool:
+        if isinstance(stmt, ast.ImportFrom) and stmt.module == "__future__":
+            for alias in stmt.names:
+                name = alias.name
+                if name in self.features:
+                    self.found_features.add(name)
+                elif name == "braces":
+                    raise SyntaxError("not a chance")
+                else:
+                    raise SyntaxError("future feature %s is not defined" % name)
+            self.valid.add(stmt)
+            return True
+        return False
+
+    def get_features(self) -> set[str]:
+        """Return set of features enabled by future statements"""
+        return self.found_features
+
+    def get_valid(self) -> set[ast.ImportFrom]:
+        """Return set of valid future statements"""
+        return self.valid
+
+
+class BadFutureParser(ASTVisitor):
+    """Check for invalid future statements"""
+
+    def __init__(self, valid_parser: FutureParser) -> None:
+        super().__init__()
+        self.valid_parser = valid_parser
+
+    def visitImportFrom(self, node: ast.ImportFrom) -> None:
+        if node.module != "__future__":
+            return
+        if node in self.valid_parser.get_valid():
+            return
+        raise SyntaxError(
+            "from __future__ imports must occur at the beginning of the file"
+        )
+
+
+def find_futures(node: ast.AST) -> set[str]:
+    p1 = FutureParser()
+    p2 = BadFutureParser(p1)
+    p1.visit(node)
+    p2.visit(node)
+    return p1.get_features()

cinderx/compiler/misc.py

@@ -0,0 +1,32 @@
+# Portions copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+
+MANGLE_LEN = 256  # magic constant from compile.c
+
+
+def mangle(name: str, klass: str | None) -> str:
+    if klass is None:
+        return name
+    if not name.startswith("__"):
+        return name
+    if len(name) + 2 >= MANGLE_LEN:
+        return name
+    # TODO: Probably need to split and mangle recursively?
+    if "." in name:
+        return name
+    if name.endswith("__"):
+        return name
+    try:
+        i = 0
+        while klass[i] == "_":
+            i = i + 1
+    except IndexError:
+        return name
+    klass = klass[i:]
+
+    tlen = len(klass) + len(name)
+    if tlen > MANGLE_LEN:
+        klass = klass[: MANGLE_LEN - tlen]
+
+    return "_{}{}".format(klass, name)

cinderx/compiler/opcode_cinder.py

@@ -0,0 +1,18 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+from .opcodebase import Opcode
+from .opcodes import opcode as base_opcode
+
+
+opcode: Opcode = base_opcode.copy()
+opcode.def_op("LOAD_METHOD_SUPER", 198)
+opcode.hasconst.add("LOAD_SUPER_METHOD")
+opcode.def_op("LOAD_ATTR_SUPER", 199)
+opcode.hasconst.add("LOAD_ATTR_SUPER")
+
+
+opcode.stack_effects.update(
+    LOAD_METHOD_SUPER=-1,
+    LOAD_ATTR_SUPER=-2,
+)

cinderx/compiler/opcode_static.py

@@ -0,0 +1,100 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# pyre-strict
+
+from .opcode_cinder import opcode as opcode_cinder
+from .opcodebase import Opcode
+
+opcode: Opcode = opcode_cinder.copy()
+opcode.def_op("INVOKE_METHOD", 158)
+opcode.hasconst.add("INVOKE_METHOD")
+opcode.def_op("LOAD_FIELD", 159)
+opcode.hasconst.add("LOAD_FIELD")
+opcode.def_op("STORE_FIELD", 166)
+opcode.hasconst.add("STORE_FIELD")
+opcode.def_op("BUILD_CHECKED_LIST", 168)
+opcode.hasconst.add("BUILD_CHECKED_LIST")
+opcode.def_op("LOAD_TYPE", 169)
+opcode.hasconst.add("LOAD_TYPE")
+opcode.def_op("CAST", 170)
+opcode.hasconst.add("CAST")
+opcode.def_op("LOAD_LOCAL", 171)
+opcode.hasconst.add("LOAD_LOCAL")
+opcode.def_op("STORE_LOCAL", 172)
+opcode.hasconst.add("STORE_LOCAL")
+opcode.def_op("PRIMITIVE_BOX", 174)
+opcode.jabs_op("POP_JUMP_IF_ZERO", 175)
+opcode.jabs_op("POP_JUMP_IF_NONZERO", 176)
+opcode.def_op("PRIMITIVE_UNBOX", 177)
+opcode.def_op("PRIMITIVE_BINARY_OP", 178)
+opcode.def_op("PRIMITIVE_UNARY_OP", 179)
+opcode.def_op("PRIMITIVE_COMPARE_OP", 180)
+opcode.def_op("LOAD_ITERABLE_ARG", 181)
+opcode.def_op("LOAD_MAPPING_ARG", 182)
+opcode.def_op("INVOKE_FUNCTION", 183)
+opcode.hasconst.add("INVOKE_FUNCTION")
+opcode.jabs_op("JUMP_IF_ZERO_OR_POP", 184)
+opcode.jabs_op("JUMP_IF_NONZERO_OR_POP", 185)
+opcode.def_op("FAST_LEN", 186)
+opcode.def_op("CONVERT_PRIMITIVE", 187)
+opcode.def_op("INVOKE_NATIVE", 189)
+opcode.hasconst.add("INVOKE_NATIVE")
+opcode.def_op("LOAD_CLASS", 190)
+opcode.hasconst.add("LOAD_CLASS")
+opcode.def_op("BUILD_CHECKED_MAP", 191)
+opcode.hasconst.add("BUILD_CHECKED_MAP")
+opcode.def_op("SEQUENCE_GET", 192)
+opcode.def_op("SEQUENCE_SET", 193)
+opcode.def_op("LIST_DEL", 194)
+opcode.def_op("REFINE_TYPE", 195)
+opcode.hasconst.add("REFINE_TYPE")
+opcode.def_op("PRIMITIVE_LOAD_CONST", 196)
+opcode.hasconst.add("PRIMITIVE_LOAD_CONST")
+opcode.def_op("RETURN_PRIMITIVE", 197)
+opcode.def_op("TP_ALLOC", 200)
+opcode.hasconst.add("TP_ALLOC")
+
+
+def _load_mapping_arg_effect(oparg: int, _jmp: int = 0) -> int:
+    if oparg == 2:
+        return -1
+    elif oparg == 3:
+        return -2
+    return 1
+
+
+opcode.stack_effects.update(
+    INVOKE_METHOD=lambda oparg, jmp: -(oparg[1] + 1),
+    LOAD_METHOD_STATIC=1,
+    LOAD_FIELD=0,
+    STORE_FIELD=-2,
+    CAST=0,
+    LOAD_LOCAL=1,
+    STORE_LOCAL=-1,
+    PRIMITIVE_BOX=0,
+    POP_JUMP_IF_ZERO=-1,
+    POP_JUMP_IF_NONZERO=-1,
+    PRIMITIVE_UNBOX=0,
+    PRIMITIVE_BINARY_OP=lambda oparg, jmp: -1,
+    PRIMITIVE_UNARY_OP=lambda oparg, jmp: 0,
+    PRIMITIVE_COMPARE_OP=lambda oparg, jmp: -1,
+    LOAD_ITERABLE_ARG=1,
+    LOAD_MAPPING_ARG=_load_mapping_arg_effect,
+    INVOKE_FUNCTION=lambda oparg, jmp=0: (-oparg[1]) + 1,
+    INVOKE_NATIVE=lambda oparg, jmp=0: (-len(oparg[1])) + 2,
+    JUMP_IF_ZERO_OR_POP=lambda oparg, jmp=0: 0 if jmp else -1,
+    JUMP_IF_NONZERO_OR_POP=lambda oparg, jmp=0: 0 if jmp else -1,
+    FAST_LEN=0,
+    CONVERT_PRIMITIVE=0,
+    LOAD_CLASS=1,
+    BUILD_CHECKED_MAP=lambda oparg, jmp: 1 - 2 * oparg[1],
+    SEQUENCE_GET=-1,
+    SEQUENCE_SET=-3,
+    LIST_DEL=-2,
+    REFINE_TYPE=0,
+    PRIMITIVE_LOAD_CONST=1,
+    RETURN_PRIMITIVE=-1,
+    TP_ALLOC=1,
+    BUILD_CHECKED_LIST=lambda oparg, jmp: 1 - oparg[1],
+    LOAD_TYPE=0,
+)

cinderx/compiler/opcodebase.py

@@ -0,0 +1,158 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+from typing import Callable
+
+
+class Opcode:
+    CMP_OP = (
+        "<",
+        "<=",
+        "==",
+        "!=",
+        ">",
+        ">=",
+        "BAD",
+    )
+    CONTAINS_OP_ARGS = (
+        "in",
+        "not in",
+    )
+    IS_OP_ARGS = (
+        "is",
+        "is not",
+    )
+
+    HAVE_ARGUMENT = 90  # Opcodes from here have an argument:
+    EXTENDED_ARG = 144
+    EXTENDED_OPCODE = 126
+    CODEUNIT_SIZE = 2
+
+    def __init__(self) -> None:
+        self.hasconst: set[str] = set()
+        self.hasname: set[int] = set()
+        self.hasjrel: set[int] = set()
+        self.hasjabs: set[int] = set()
+        self.haslocal: set[int] = set()
+        self.hascompare: set[int] = set()
+        self.hasfree: set[int] = set()
+        self.shadowop: set[int] = set()
+
+        self.opmap: dict[str, int] = {}
+        self.opname: list[str] = ["<{!r}>".format(op) for op in range(256)]
+        self.stack_effects: dict[str, object] = {}
+
+        # New for 3.14, we need to know popped vs pushed for the load borrow analysis.
+        self.popped: dict[str, int | Callable[[object], int]] = {}
+        self.pushed: dict[str, int | Callable[[object], int]] = {}
+
+    def stack_effect(self, opcode: int, oparg, jump: int) -> int:  # pyre-ignore[2]
+        oparg_int = 0
+        if opcode >= self.HAVE_ARGUMENT:
+            if oparg is None:
+                raise ValueError(
+                    "stack_effect: opcode requires oparg but oparg was not specified"
+                )
+            oparg_int = int(oparg)
+        elif oparg is not None:
+            raise ValueError(
+                "stack_effect: opcode does not permit oparg but oparg was specified"
+            )
+        # pyre-fixme[6]: For 1st argument expected `Optional[bool]` but got `int`.
+        jump_int = {None: -1, True: 1, False: 0}.get(jump)
+        if jump_int is None:
+            raise ValueError("stack_effect: jump must be False, True or None")
+        opname = self.opname[opcode]
+        return self.stack_effect_raw(opname, oparg_int, jump_int)
+
+    def stack_effect_raw(self, opname: str, oparg, jump: int) -> int:  # pyre-ignore[2]
+        effect = self.stack_effects.get(opname)
+        if effect is None:
+            raise ValueError(
+                f"Error, opcode {opname} was not found, please update opcode.stack_effects"
+            )
+        if isinstance(effect, int):
+            return effect
+        else:
+            return effect(oparg, jump)  # pyre-ignore[29]
+
+    def get_num_popped(self, opname: str, oparg: object) -> int:
+        popped = self.popped.get(opname)
+        if popped is None:
+            raise ValueError(
+                f"Error, opcode {opname} was not found, please update opcode.stack_effects"
+            )
+        if isinstance(popped, int):
+            return popped
+        else:
+            return popped(oparg)
+
+    def get_num_pushed(self, opname: str, oparg: object) -> int:
+        pushed = self.pushed.get(opname)
+        if pushed is None:
+            raise ValueError(
+                f"Error, opcode {opname} was not found, please update opcode.stack_effects"
+            )
+        if isinstance(pushed, int):
+            return pushed
+        else:
+            return pushed(oparg)
+
+    def def_op(self, name: str, op: int) -> None:
+        # Fill in any missing space in the opname list for
+        # opargs which are > 255.
+        while op >= len(self.opname):
+            self.opname.append("<{!r}>".format(op))
+        self.opname[op] = name
+        self.opmap[name] = op
+        setattr(self, name, op)
+
+    def name_op(self, name: str, op: int) -> None:
+        self.def_op(name, op)
+        self.hasname.add(op)
+
+    def jrel_op(self, name: str, op: int) -> None:
+        self.def_op(name, op)
+        self.hasjrel.add(op)
+
+    def jabs_op(self, name: str, op: int) -> None:
+        self.def_op(name, op)
+        self.hasjabs.add(op)
+
+    def has_jump(self, op: int) -> bool:
+        return op in self.hasjrel or op in self.hasjabs
+
+    def shadow_op(self, name: str, op: int) -> None:
+        self.def_op(name, op)
+        self.shadowop.add(op)
+
+    def remove_op(self, opname: str) -> None:
+        op = self.opmap[opname]
+        self.hasconst.discard(opname)
+        self.hasname.discard(op)
+        self.hasjrel.discard(op)
+        self.hasjabs.discard(op)
+        self.haslocal.discard(op)
+        self.hascompare.discard(op)
+        self.hasfree.discard(op)
+        self.shadowop.discard(op)
+        self.opmap.pop(opname)
+        self.opname[op] = None  # pyre-ignore[6]
+        self.stack_effects.pop(opname)
+        delattr(self, opname)
+
+    def copy(self) -> "Opcode":
+        result = Opcode()
+        result.hasconst = self.hasconst.copy()
+        result.hasname = self.hasname.copy()
+        result.hasjrel = self.hasjrel.copy()
+        result.hasjabs = self.hasjabs.copy()
+        result.haslocal = self.haslocal.copy()
+        result.hascompare = self.hascompare.copy()
+        result.hasfree = self.hasfree.copy()
+        result.shadowop = self.shadowop.copy()
+        result.opmap = self.opmap.copy()
+        result.opname = self.opname.copy()
+        result.stack_effects = self.stack_effects.copy()
+        for name, op in self.opmap.items():
+            setattr(result, name, op)
+        return result