RwLock

Added a cached effective_sys_info to module state so once a platform guard is discovered it persists even if the AST is cleared.
Updated import/look‑up and step context construction to use the cached effective sys_info, eliminating the mismatch that led to missing builtins.WindowsError and the LookupAnswer::get panic.

Author: asukaminato0721

pyrefly/lib/state/state.rs

@@ -366,6 +366,7 @@ impl ModuleDeps {
 struct ModuleData {
     handle: Handle,
     config: ArcId<ConfigFile>,
+    effective_sys_info: SysInfo,
     state: ModuleState,
     imports: HashMap<ModuleName, FindingOrError<ModulePath>, BuildNoHash>,
     deps: HashMap<Handle, ModuleDeps>,
@@ -376,6 +377,7 @@ struct ModuleData {
 struct ModuleDataMut {
     handle: Handle,
     config: RwLock<ArcId<ConfigFile>>,
+    effective_sys_info: RwLock<SysInfo>,
     state: ModuleStateMut,
     /// Import resolution cache: module names from import statements → resolved paths.
     /// Only contains deps that were resolved via `find_import`.
@@ -404,6 +406,7 @@ impl ModuleData {
         ModuleDataMut {
             handle: self.handle.dupe(),
             config: RwLock::new(self.config.dupe()),
+            effective_sys_info: RwLock::new(self.effective_sys_info.dupe()),
             state: self.state.clone_for_mutation(),
             imports: RwLock::new(self.imports.clone()),
             deps: RwLock::new(self.deps.clone()),
@@ -414,9 +417,11 @@ impl ModuleData {
 
 impl ModuleDataMut {
     fn new(handle: Handle, require: Require, config: ArcId<ConfigFile>, now: Epoch) -> Self {
+        let effective_sys_info = handle.sys_info().dupe();
         Self {
             handle,
             config: RwLock::new(config),
+            effective_sys_info: RwLock::new(effective_sys_info),
             state: ModuleStateMut::new(require, now),
             imports: Default::default(),
             deps: Default::default(),
@@ -430,6 +435,7 @@ impl ModuleDataMut {
         let ModuleDataMut {
             handle,
             config,
+            effective_sys_info,
             state,
             imports,
             deps,
@@ -442,13 +448,26 @@ impl ModuleDataMut {
         ModuleData {
             handle: handle.dupe(),
             config: config.read().dupe(),
+            effective_sys_info: effective_sys_info.read().dupe(),
             state,
             imports,
             deps,
             rdeps,
         }
     }
 
+    fn effective_sys_info(&self) -> SysInfo {
+        if let Some(ast) = self.state.get_ast().as_deref() {
+            let base = self.handle.sys_info();
+            let effective =
+                module_sys_info_override(base, Some(ast)).unwrap_or_else(|| base.dupe());
+            *self.effective_sys_info.write() = effective.dupe();
+            effective
+        } else {
+            self.effective_sys_info.read().dupe()
+        }
+    }
+
     /// Look up how this module depends on a specific source handle.
     /// Returns the `ModuleDep` if this module depends on `source_handle`, or `None` if not found.
     fn get_depends_on(&self, source_handle: &Handle) -> Option<ModuleDeps> {
@@ -1023,18 +1042,12 @@ impl<'a> Transaction<'a> {
             let require = guard.require();
             let stdlib = self.get_stdlib(&module_data.handle);
             let config = module_data.config.read();
-            let sys_info_override = module_sys_info_override(
-                module_data.handle.sys_info(),
-                module_data.state.get_ast().as_deref(),
-            );
-            let sys_info = sys_info_override
-                .as_ref()
-                .unwrap_or(module_data.handle.sys_info());
+            let sys_info = module_data.effective_sys_info();
             let ctx = Context {
                 require,
                 module: module_data.handle.module(),
                 path: module_data.handle.path(),
-                sys_info,
+                sys_info: &sys_info,
                 memory: &self.memory_lookup(),
                 uniques: &self.data.state.uniques,
                 stdlib: &stdlib,
@@ -2003,13 +2016,7 @@ impl<'a> TransactionHandle<'a> {
         path: Option<&ModulePath>,
         dep: ModuleDep,
     ) -> FindingOrError<ArcId<ModuleDataMut>> {
-        let sys_info_override = module_sys_info_override(
-            self.module_data.handle.sys_info(),
-            self.module_data.state.get_ast().as_deref(),
-        );
-        let sys_info = sys_info_override
-            .as_ref()
-            .unwrap_or(self.module_data.handle.sys_info());
+        let sys_info = self.module_data.effective_sys_info();
         let handle = match path {
             Some(path) => {
                 // Explicit path — already resolved. Bypass imports entirely.