Don't give reference targets in Buck outputs a Glean file

Summary:
**Problem.** Pyrefly's Glean report (`--report-glean`) records, for each reference and import in an indexed file, the target's name and the file that defines it. That file is the target module's path relative to the working directory. When Pyrefly resolves imports through Buck (e.g. with `fbcode/pyrefly.toml`), generated modules such as Thrift Python packages resolve to build outputs, so the facts name files like `buck-out/.pyrelsp/art/fbcode/<path>/__<target>-python-<x>.thrift__/<hash>/out/gen-python/<pkg>`. In a test of `fbsource.genai.python.pyrefly` with Buck resolution, 285 such paths ended up in `src.File`. They contain a configuration hash, they change from build to build, and Glean never indexes those files, so they are noise in the DB.

The Pyre-based Glean DB `fbsource.fbcode.python`, which the Pyrefly DB `fbsource.fbcode.python.pyrefly` is replacing (T291925475), has no `buck-out` paths: it only writes facts for the source files it indexes, and references reach generated code by name.

**Change.** When the module that defines a reference target is not a source file of the repository (it is under `buck-out/`, or outside the working directory), the reference's definition location now has no file. This state already exists: `DefinitionLocation.file` is an `Option` and is `None` when Pyrefly can't find a definition. The target name is kept, so name-based references (`python.XRefViaName`) are unchanged. The indexed file's own `src.File` is unaffected.

Review: `definition_file_fact` in `pyrefly/lib/report/glean/convert.rs`, its two call sites (`get_definition_location`, `find_definition_for_imported_module`), then the tests.

___

landed-with-radar-review

Differential Revision: D125429038

fbshipit-source-id: 6e69c873cf2ad3930a3b0b87eab9f7d75cd2149a

Author: Catherine Gasnier

pyrefly/lib/report/glean/convert.rs

@@ -10,6 +10,7 @@ use std::collections::HashSet;
 use std::collections::VecDeque;
 use std::env::current_dir;
 use std::ops::Sub;
+use std::path::Path;
 use std::slice;
 use std::sync::Arc;
 
@@ -165,6 +166,16 @@ fn file_fact(module_info: &ModuleInfo) -> src::File {
     src::File::new(relative_path.replace('\\', "/"))
 }
 
+/// The file fact of the module that defines a cross-module reference target, or `None` if that
+/// module is not a source file of the repository: a Buck build output under `buck-out/` (e.g. a
+/// generated Thrift module) or a file outside the working directory. Glean only indexes source
+/// files, so such a file would never have facts of its own. The target name is kept either way.
+fn definition_file_fact(module_info: &ModuleInfo) -> Option<src::File> {
+    let file = file_fact(module_info);
+    let is_source_file = !file.key.starts_with("buck-out/") && !Path::new(&*file.key).is_absolute();
+    is_source_file.then_some(file)
+}
+
 fn gather_nonlocal_variables(body: &[Stmt]) -> (Arc<SmallSet<Name>>, Arc<SmallSet<Name>>) {
     let mut globals = SmallSet::new();
     let mut nonlocals = SmallSet::new();
@@ -525,7 +536,7 @@ impl GleanState<'_> {
         base_type: Option<&Type>,
         additional_definitions: Vec<DefinitionLocation>,
     ) -> Vec<DefinitionLocation> {
-        let file = Some(file_fact(module));
+        let file = definition_file_fact(module);
         let type_name = base_type.and_then(|ty| ty.qname());
         let local_name = module.code_at(def_range);
         let module_name = module.name();
@@ -1236,7 +1247,7 @@ impl GleanState<'_> {
             .unwrap_or(None);
 
         let name = module.to_string();
-        let file = definition.map(|def| file_fact(&def.module));
+        let file = definition.and_then(|def| definition_file_fact(&def.module));
 
         DefinitionLocation { name, file }
     }
@@ -1761,8 +1772,44 @@ pub fn glean(transaction: &Transaction, handle: &Handle, ownership: bool) -> Gle
 
 #[cfg(test)]
 mod tests {
+    use std::path::PathBuf;
+
+    use pyrefly_python::module_path::ModulePath;
+
     use super::*;
 
+    fn module_at(path: &str) -> ModuleInfo {
+        ModuleInfo::new(
+            ModuleName::from_str("m"),
+            ModulePath::filesystem(PathBuf::from(path)),
+            Arc::new(String::new()),
+        )
+    }
+
+    #[test]
+    fn test_definition_file_fact_source_file() {
+        let file = definition_file_fact(&module_at("fbcode/foo/bar.py"));
+        assert_eq!(file.map(|f| *f.key), Some("fbcode/foo/bar.py".to_owned()));
+    }
+
+    #[test]
+    fn test_definition_file_fact_buck_out() {
+        let path = "buck-out/.pyrelsp/art/fbcode/foo/__bar-python-bar.thrift__/out/gen-python/foo";
+        assert!(
+            definition_file_fact(&module_at(path)).is_none(),
+            "Buck outputs have no file fact"
+        );
+    }
+
+    #[test]
+    fn test_definition_file_fact_outside_working_directory() {
+        let file = definition_file_fact(&module_at("/nonexistent/site-packages/foo.py"));
+        assert!(
+            file.is_none(),
+            "files outside the working directory have no file fact"
+        );
+    }
+
     #[test]
     fn test_compute_scope_module() {
         assert_eq!(