All files static, support opt-out in PyreflyCompiler

Summary: Makes the Pyrefly compiler treat all modules as strict and adds an opt-out. Extends testing to make sure that works.

Reviewed By: alexmalyshev

Differential Revision: D95993330

fbshipit-source-id: 0814d310f5d2929154e64a94e72fa778cfd9e8aa

Author: DinoV

cinderx/PythonLib/cinderx/compiler/static/pyrefly_compiler.py

@@ -1,25 +1,39 @@
 # Copyright (c) Meta Platforms, Inc. and affiliates.
 
-from cinderx.compiler.errors import ErrorSink
-from cinderx.compiler.static import Compiler, StaticCodeGenBase
+import ast
+import sys
+
 from cinderx.compiler.static.pyrefly_type_binder import (
     PyreflyTypeBinder,
     PyreflyTypeInfo,
 )
 from cinderx.compiler.static.type_binder import TypeBinder
+from cinderx.compiler.strict.compiler import Compiler
+from cinderx.compiler.strict.flag_extractor import Flags
 from cinderx.compiler.symbols import SymbolVisitor
 
 
 class PyreflyCompiler(Compiler):
     def __init__(
         self,
-        code_generator: type[StaticCodeGenBase],
-        error_sink: ErrorSink | None = None,
         type_info: PyreflyTypeInfo | None = None,
+        non_static_modules: set[str] | None = None,
     ):
-        super().__init__(code_generator, error_sink)
+        super().__init__(sys.path, "", [], [])
         assert type_info is not None
         self.type_info = type_info
+        self.non_static_modules = non_static_modules
+
+    def get_flags(
+        self, module_name: str, pyast: ast.Module, override_flags: Flags
+    ) -> Flags:
+        if self.non_static_modules is not None:
+            if module_name in self.non_static_modules:
+                return Flags().merge(override_flags)
+
+            return Flags(is_static=True).merge(override_flags)
+
+        return super().get_flags(module_name, pyast, override_flags)
 
     def make_type_binder(
         self,

cinderx/PythonLib/cinderx/compiler/strict/compiler.py

@@ -185,6 +185,11 @@ def _setup_logging(self) -> logging.Logger:
             logger.setLevel(logging.DEBUG)
         return logger
 
+    def get_flags(
+        self, module_name: str, pyast: ast.Module, override_flags: Flags
+    ) -> Flags:
+        return FlagExtractor().get_flags(pyast).merge(override_flags)
+
     def load_compiled_module_from_source(
         self,
         source: str | bytes,
@@ -197,7 +202,7 @@ def load_compiled_module_from_source(
         pyast = ast.parse(source)
         # pyre-fixme[6]: For 1st argument expected `str` but got `Union[bytes, str]`.
         symbols = symtable.symtable(source, filename, "exec")
-        flags = FlagExtractor().get_flags(pyast).merge(override_flags)
+        flags = self.get_flags(name, pyast, override_flags)
 
         if not flags.is_static and not flags.is_strict:
             code = self._compile_basic(name, pyast, filename, optimize)

cinderx/PythonLib/test_cinderx/test_compiler/test_static/pyrefly_binder.py

@@ -4,24 +4,46 @@
 import unittest
 from types import CodeType
 
-from cinderx.compiler.static import StaticCodeGenerator
 from cinderx.compiler.static.pyrefly_compiler import PyreflyCompiler
 from cinderx.compiler.static.pyrefly_type_binder import PyreflyTypeInfo
 
 from .common import StaticTestBase
 
 
+EMPTY_TYPE_INFO = PyreflyTypeInfo(
+    {
+        "type_table": [],
+        "locations": [],
+    }
+)
+
+
 class PyreBinderTests(StaticTestBase):
     def test_simple(self):
-        code = self.compile_one(
+        self.compile_one(
             "x = 1 + 2",
-            PyreflyTypeInfo(
-                {
-                    "type_table": [],
-                    "locations": [],
-                }
-            ),
+            EMPTY_TYPE_INFO,
+        )
+
+    def test_force_static(self):
+        compiler = PyreflyCompiler(non_static_modules=set(), type_info=EMPTY_TYPE_INFO)
+        code, strict, static = compiler.load_compiled_module_from_source(
+            "def f(x: int): return x.bit_length()", "foo.py", "foo", 0
+        )
+        self.assertTrue(static)
+        self.assertFalse(strict)
+        self.assertIn("<fixed-modules>", code.co_names)
+
+    def test_non_force_static(self):
+        compiler = PyreflyCompiler(
+            non_static_modules={"foo"}, type_info=EMPTY_TYPE_INFO
+        )
+        code, strict, static = compiler.load_compiled_module_from_source(
+            "def f(x: int): return x.bit_length()", "foo.py", "foo", 0
         )
+        self.assertFalse(static)
+        self.assertFalse(strict)
+        self.assertNotIn("<fixed-modules>", code.co_names)
 
     def compile_one(
         self,
@@ -32,7 +54,7 @@ def compile_one(
         ast_optimizer_enabled: bool = True,
         enable_patching: bool = False,
     ) -> CodeType:
-        compiler = PyreflyCompiler(StaticCodeGenerator, type_info=type_info)
+        compiler = PyreflyCompiler(type_info=type_info)
         tree = ast.parse(self.clean_code(code))
         return compiler.compile(
             modname,