cinderx 2026.1.16.2__cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

cinderx/compiler/static/declaration_visitor.py

@@ -0,0 +1,335 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# pyre-strict
+
+from __future__ import annotations
+
+import ast
+from ast import (
+    AnnAssign,
+    Assign,
+    AST,
+    AsyncFor,
+    AsyncFunctionDef,
+    AsyncWith,
+    ClassDef,
+    For,
+    FunctionDef,
+    If,
+    Import,
+    ImportFrom,
+    Name,
+    Try,
+    While,
+    With,
+)
+from typing import TYPE_CHECKING, Union
+
+from .module_table import DeferredImport, ModuleTable
+from .types import (
+    AwaitableTypeRef,
+    Class,
+    DecoratedMethod,
+    Function,
+    InitSubclassFunction,
+    ResolvedTypeRef,
+    TypeEnvironment,
+    TypeName,
+    TypeRef,
+    UnknownDecoratedMethod,
+)
+from .util import make_qualname, sys_hexversion_check
+from .visitor import GenericVisitor
+
+if TYPE_CHECKING:
+    from .compiler import Compiler
+
+
+class NestedScope:
+    def __init__(self, parent_qualname: str | None) -> None:
+        self.qualname: str = make_qualname(parent_qualname, "<nested>")
+
+    def declare_class(self, node: AST, klass: Class) -> None:
+        pass
+
+    def declare_function(self, func: Function | DecoratedMethod) -> None:
+        pass
+
+    def declare_variable(self, node: AnnAssign, module: ModuleTable) -> None:
+        pass
+
+    def declare_variables(self, node: Assign, module: ModuleTable) -> None:
+        pass
+
+    # pyre-ignore[11]: Annotation `ast.TypeAlias` is not defined as a type
+    def declare_type_alias(self, node: ast.TypeAlias) -> None:
+        pass
+
+
+TScopeTypes = Union[ModuleTable, Class, Function, NestedScope]
+
+
+class DeclarationVisitor(GenericVisitor[None]):
+    def __init__(
+        self, mod_name: str, filename: str, symbols: Compiler, optimize: int
+    ) -> None:
+        module = symbols[mod_name] = ModuleTable(
+            mod_name, filename, symbols, first_pass_done=False
+        )
+        super().__init__(module)
+        self.scopes: list[TScopeTypes] = [self.module]
+        self.optimize = optimize
+        self.compiler = symbols
+        self.type_env: TypeEnvironment = symbols.type_env
+
+    def finish_bind(self) -> None:
+        self.module.finish_bind()
+
+    def parent_scope(self) -> TScopeTypes:
+        return self.scopes[-1]
+
+    def enter_scope(self, scope: TScopeTypes) -> None:
+        self.scopes.append(scope)
+
+    def exit_scope(self) -> None:
+        self.scopes.pop()
+
+    def qualify_name(self, name: str) -> str:
+        return make_qualname(self.parent_scope().qualname, name)
+
+    def make_nested_scope(self) -> NestedScope:
+        return NestedScope(self.parent_scope().qualname)
+
+    def enter_nested_scope(self) -> None:
+        self.enter_scope(self.make_nested_scope())
+
+    def visitAnnAssign(self, node: AnnAssign) -> None:
+        self.parent_scope().declare_variable(node, self.module)
+
+    def visitAssign(self, node: Assign) -> None:
+        self.parent_scope().declare_variables(node, self.module)
+
+    # pyre-ignore[11]: Annotation `ast.TypeAlias` is not defined as a type
+    def visitTypeAlias(self, node: ast.TypeAlias) -> None:
+        self.parent_scope().declare_type_alias(node)
+
+    def visitClassDef(self, node: ClassDef) -> None:
+        parent_scope = self.parent_scope()
+        qualname = make_qualname(parent_scope.qualname, node.name)
+
+        bases = [
+            self.module.resolve_type(base, qualname) or self.type_env.dynamic
+            for base in node.bases
+        ]
+        if not bases:
+            bases.append(self.type_env.object)
+
+        with self.compiler.error_sink.error_context(self.filename, node):
+            klasses = []
+            for base in bases:
+                klasses.append(
+                    base.make_subclass(
+                        TypeName(self.module_name, qualname),
+                        bases,
+                    )
+                )
+            for cur_type in klasses:
+                if type(cur_type) is not type(klasses[0]):
+                    self.syntax_error("Incompatible subtypes", node)
+            klass = klasses[0]
+
+        for base in bases:
+            if base is self.type_env.named_tuple:
+                # In named tuples, the fields are actually elements
+                # of the tuple, so we can't do any advanced binding against it.
+                klass = self.type_env.dynamic
+                break
+
+            if base is self.type_env.protocol:
+                # Protocols aren't guaranteed to exist in the actual MRO, so let's treat
+                # them as dynamic to force dynamic dispatch.
+                klass = self.type_env.dynamic
+                break
+
+            if base is self.type_env.typed_dict:
+                # TASK(T121706684) Supporting typed dicts is tricky, similar
+                # to protocols and named tuples
+                klass = self.type_env.dynamic
+                break
+
+            if base.is_final:
+                self.syntax_error(
+                    f"Class `{klass.instance.name}` cannot subclass a Final class: `{base.instance.name}`",
+                    node,
+                )
+
+        # we can't statically load classes nested inside functions
+        if not isinstance(parent_scope, (ModuleTable, Class)):
+            klass = self.type_env.dynamic
+
+        self.enter_scope(
+            self.make_nested_scope() if klass is self.type_env.dynamic else klass
+        )
+        for item in node.body:
+            with self.compiler.error_sink.error_context(self.filename, item):
+                self.visit(item)
+        self.exit_scope()
+
+        for d in reversed(node.decorator_list):
+            if klass is self.type_env.dynamic:
+                break
+            with self.compiler.error_sink.error_context(self.filename, d):
+                decorator = self.module.resolve_decorator(d) or self.type_env.dynamic
+                klass = decorator.resolve_decorate_class(klass, d, self)
+
+        parent_scope.declare_class(node, klass.exact_type())
+        # We want the name corresponding to `C` to be the exact type when imported.
+        self.module.types[node] = klass.exact_type()
+
+    def _visitFunc(self, node: FunctionDef | AsyncFunctionDef) -> None:
+        function = self._make_function(node)
+        self.parent_scope().declare_function(function)
+
+    def _make_function(self, node: FunctionDef | AsyncFunctionDef) -> Function:
+        qualname = self.qualify_name(node.name)
+        if node.name == "__init_subclass__":
+            func = InitSubclassFunction(
+                node, self.module, self.return_type_ref(node, qualname)
+            )
+            parent_scope = self.parent_scope()
+            if isinstance(parent_scope, Class):
+                parent_scope.has_init_subclass = True
+        else:
+            func = Function(node, self.module, self.return_type_ref(node, qualname))
+        self.enter_scope(func)
+        for item in node.body:
+            self.visit(item)
+        self.exit_scope()
+
+        func_type = func
+        if node.decorator_list:
+            # Since we haven't resolved decorators yet (until finish_bind), we
+            # don't know what type we should ultimately set for this node;
+            # Function.finish_bind() will likely override this.
+            func_type = UnknownDecoratedMethod(func, node.decorator_list[0])
+
+        self.module.types[node] = func_type
+        return func
+
+    def visitFunctionDef(self, node: FunctionDef) -> None:
+        self._visitFunc(node)
+
+    def visitAsyncFunctionDef(self, node: AsyncFunctionDef) -> None:
+        self._visitFunc(node)
+
+    def return_type_ref(
+        self, node: FunctionDef | AsyncFunctionDef, requester: str
+    ) -> TypeRef:
+        ann = node.returns
+        if not ann:
+            res = ResolvedTypeRef(self.type_env.dynamic)
+        else:
+            res = TypeRef(self.module, requester, ann)
+        if isinstance(node, AsyncFunctionDef):
+            res = AwaitableTypeRef(res, self.module.compiler)
+        return res
+
+    def visitImport(self, node: Import) -> None:
+        for name in node.names:
+            asname = name.asname
+            if asname is None:
+                top_level_module = name.name.split(".")[0]
+                self.module.declare_import(
+                    top_level_module,
+                    None,
+                    DeferredImport(
+                        self.module,
+                        name.name,
+                        top_level_module,
+                        self.optimize,
+                        self.compiler,
+                        mod_to_return=top_level_module,
+                    ),
+                )
+            else:
+                self.module.declare_import(
+                    asname,
+                    None,
+                    DeferredImport(
+                        self.module, name.name, asname, self.optimize, self.compiler
+                    ),
+                )
+
+    def visitImportFrom(self, node: ImportFrom) -> None:
+        mod_name = node.module
+        if not mod_name or node.level:
+            raise NotImplementedError("relative imports aren't supported")
+        for name in node.names:
+            child_name = name.asname or name.name
+            self.module.declare_import(
+                child_name,
+                (mod_name, name.name),
+                DeferredImport(
+                    self.module,
+                    mod_name,
+                    name.name,
+                    self.optimize,
+                    self.compiler,
+                    name.name,
+                ),
+            )
+
+    # We don't pick up declarations in nested statements
+    def visitFor(self, node: For) -> None:
+        self.enter_nested_scope()
+        self.generic_visit(node)
+        self.exit_scope()
+
+    def visitAsyncFor(self, node: AsyncFor) -> None:
+        self.enter_nested_scope()
+        self.generic_visit(node)
+        self.exit_scope()
+
+    def visitWhile(self, node: While) -> None:
+        self.enter_nested_scope()
+        self.generic_visit(node)
+        self.exit_scope()
+
+    def visitIf(self, node: If) -> None:
+        test = node.test
+        if isinstance(test, Name) and test.id == "TYPE_CHECKING":
+            self.visit_list(node.body)
+        else:
+            result = sys_hexversion_check(node)
+            # We should check the version if provided
+            if result is not None:
+                self.module.mark_known_boolean_test(test, value=bool(result))
+                if result:
+                    self.visit_list(node.body)
+                else:
+                    self.visit_list(node.orelse)
+                return
+            else:
+                self.enter_nested_scope()
+                self.visit_list(node.body)
+                self.exit_scope()
+
+        if node.orelse:
+            self.enter_nested_scope()
+            self.visit_list(node.orelse)
+            self.exit_scope()
+
+    def visitWith(self, node: With) -> None:
+        self.enter_nested_scope()
+        self.generic_visit(node)
+        self.exit_scope()
+
+    def visitAsyncWith(self, node: AsyncWith) -> None:
+        self.enter_nested_scope()
+        self.generic_visit(node)
+        self.exit_scope()
+
+    def visitTry(self, node: Try) -> None:
+        self.enter_nested_scope()
+        self.generic_visit(node)
+        self.exit_scope()

cinderx/compiler/static/definite_assignment_checker.py

@@ -0,0 +1,280 @@
+# @oncall strictmod
+
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+from __future__ import annotations
+
+import ast
+from ast import (
+    AnnAssign,
+    Assign,
+    AsyncFunctionDef,
+    AugAssign,
+    ClassDef,
+    For,
+    FunctionDef,
+    If,
+    Import,
+    ImportFrom,
+    Lambda,
+    Name,
+    NodeVisitor,
+    Raise,
+    stmt,
+    Try,
+    While,
+    With,
+)
+from typing import Iterable
+
+from ..consts import SC_CELL, SC_LOCAL
+from ..symbols import Scope
+
+
+class DefiniteAssignmentVisitor(NodeVisitor):
+    def __init__(self, scope: Scope) -> None:
+        self.scope = scope
+        self.assigned: set[str] = set()
+        self.unassigned: set[Name] = set()
+
+    def analyzeFunction(self, node: FunctionDef | AsyncFunctionDef) -> None:
+        for arg in node.args.args:
+            self.assigned.add(arg.arg)
+        for arg in node.args.kwonlyargs:
+            self.assigned.add(arg.arg)
+        for arg in node.args.posonlyargs:
+            self.assigned.add(arg.arg)
+
+        vararg = node.args.vararg
+        if vararg:
+            self.assigned.add(vararg.arg)
+        kwarg = node.args.kwarg
+        if kwarg:
+            self.assigned.add(kwarg.arg)
+        for body_stmt in node.body:
+            self.visit(body_stmt)
+
+    def set_assigned(self, name: str) -> None:
+        if self.is_local(name):
+            self.assigned.add(name)
+
+    def is_local(self, name: str) -> bool:
+        scope = self.scope.check_name(name)
+        return scope == SC_LOCAL or scope == SC_CELL
+
+    def visit_Name(self, node: Name) -> None:
+        # we only walk the module and class defs and nested class defs
+        # can't access parent class def variables, so the variable is
+        # definitely assigned in the inner most class def
+        # TODO: T52624111 needs special handling for __class__
+        if not self.is_local(node.id):
+            return
+
+        if isinstance(node.ctx, ast.Load):
+            if node.id not in self.assigned:
+                self.unassigned.add(node)
+        elif isinstance(node.ctx, ast.Del):
+            if node.id not in self.assigned:
+                self.unassigned.add(node)
+            else:
+                self.assigned.remove(node.id)
+        else:
+            self.assigned.add(node.id)
+
+    def visit_Assign(self, node: Assign) -> None:
+        # generic_visit will evaluate these in a different order due to _fields
+        # being targets, value
+        self.visit(node.value)
+        for target in node.targets:
+            self.visit(target)
+
+    def visit_AugAssign(self, node: AugAssign) -> None:
+        target = node.target
+        if isinstance(target, ast.Name):
+            if target.id not in self.assigned:
+                self.unassigned.add(target)
+            self.generic_visit(node.value)
+            return
+
+        self.generic_visit(node)
+
+    def visit_Try(self, node: Try) -> None:
+        if not node.handlers:
+            # Try/finally, all assignments are guaranteed
+            entry = set(self.assigned)
+            self.walk_stmts(node.body)
+
+            post_try = set(self.assigned)
+
+            # finally is not guaranteed to have any try statements executed,
+            # but any deletes should be assumed
+            self.assigned = entry.intersection(post_try)
+
+            self.walk_stmts(node.finalbody)
+
+            # Anything the finally deletes is removed (the finally cannot delete
+            # things which weren't defined on entry, because they aren't definitely
+            # assigned)
+            for value in entry:
+                if value not in self.assigned and value in post_try:
+                    post_try.remove(value)
+            #
+            # Anything that was assigned in the try is assigned after
+            post_try.update(self.assigned)
+            self.assigned = post_try
+            return
+
+        # try/except/maybe finally.  Only the finally assignments are guaranteed
+        entry = set(self.assigned)
+        self.walk_stmts(node.body)
+        # Remove anything that got deleted...
+
+        elseentry = set(self.assigned)
+        entry.intersection_update(self.assigned)
+
+        finalentry = set(entry)
+        for handler in node.handlers:
+            self.assigned = set(entry)
+            handler_name = handler.name
+            if handler_name is not None:
+                self.set_assigned(handler_name)
+
+            self.walk_stmts(handler.body)
+            # All deletes for any entry apply to the finally
+            finalentry.intersection_update(self.assigned)
+
+        if node.orelse:
+            self.assigned = elseentry
+            self.walk_stmts(node.orelse)
+            finalentry.intersection_update(self.assigned)
+
+        self.assigned = finalentry
+        if node.finalbody:
+            self.walk_stmts(node.finalbody)
+
+    def visit_ClassDef(self, node: ClassDef) -> None:
+        for base in node.bases:
+            self.visit(base)
+
+        for kw in node.keywords:
+            self.visit(kw)
+
+        for dec in node.decorator_list:
+            self.visit(dec)
+
+        self.set_assigned(node.name)
+
+    def visit_FunctionDef(self, node: FunctionDef) -> None:
+        self._visit_func_like(node)
+
+    def visit_AsyncFunctionDef(self, node: AsyncFunctionDef) -> None:
+        self._visit_func_like(node)
+
+    def visit_Lambda(self, node: Lambda) -> None:
+        self.visit(node.args)
+
+    def _visit_func_like(self, node: FunctionDef | AsyncFunctionDef) -> None:
+        self.visit(node.args)
+
+        returns = node.returns
+        if returns:
+            self.visit(returns)
+
+        for dec in node.decorator_list:
+            self.visit(dec)
+
+        # Body doesn't run so isn't processed
+        self.set_assigned(node.name)
+
+    def visit_With(self, node: With) -> None:
+        # All of the with items will be definitely assigned
+        for item in node.items:
+            self.visit(item)
+
+        entry = set(self.assigned)
+
+        self.walk_stmts(node.body)
+        # No assignments are guaranteed, the body can throw and the context
+        # manager can suppress it.  But all deletes need to be assumed to have
+        # occurred
+        entry.intersection_update(self.assigned)
+        self.assigned = entry
+
+    def visit_Import(self, node: Import) -> None:
+        for name in node.names:
+            self.set_assigned(name.asname or name.name.partition(".")[0])
+
+    def visit_ImportFrom(self, node: ImportFrom) -> None:
+        for name in node.names:
+            self.set_assigned(name.asname or name.name)
+
+    def visit_AnnAssign(self, node: AnnAssign) -> None:
+        # We won't actually define anything w/o a value
+        if node.value:
+            self.generic_visit(node)
+
+    # Don't need AsyncFor, AsyncWith Return as they can't be present at
+    # module / class level
+
+    def visit_For(self, node: For) -> None:
+        self.visit(node.iter)
+
+        entry = set(self.assigned)
+        self.visit(node.target)
+        self.walk_stmts(node.body)
+
+        # no assigns are guaranteed, need to assume deletes occur, and
+        # they impact the else block too.
+        entry.intersection_update(self.assigned)
+        if node.orelse:
+            self.assigned = set(entry)
+            self.walk_stmts(node.orelse)
+
+            # else may not run, so again no signs guaranteed, deletes are assumed
+            entry.intersection_update(self.assigned)
+
+        self.assigned = entry
+
+    def visit_If(self, node: If) -> None:
+        self.visit(node.test)
+        entry = set(self.assigned)
+        self.walk_stmts(node.body)
+
+        post_if = self.assigned
+
+        if node.orelse:
+            self.assigned = set(entry)
+
+            self.walk_stmts(node.orelse)
+
+            self.assigned = self.assigned.intersection(post_if)
+        else:
+            # Remove anything which was deleted
+            entry.intersection_update(post_if)
+            self.assigned = entry
+
+    def visit_While(self, node: While) -> None:
+        self.visit(node.test)
+        entry = set(self.assigned)
+        self.walk_stmts(node.body)
+
+        # Any dels will remove assignment
+        entry.intersection_update(self.assigned)
+        if node.orelse:
+            self.assigned = set(entry)
+
+            self.walk_stmts(node.orelse)
+            # Any dels will remove definite assignment
+            entry.intersection_update(self.assigned)
+
+        # While loop may never be entered, else may never be entered, so
+        # it never definitely assigns anything
+        self.assigned = entry
+
+    def walk_stmts(self, nodes: Iterable[stmt]) -> None:
+        for node in nodes:
+            self.visit(node)
+            if isinstance(node, Raise):
+                # following statements are unreachable
+                return