Add a target python version option to lifeguard

Summary:
Prerequisite for supporting the new `lazy` keyword, since we want to gate that
to 3.15+. Also addresses the fact that open source users will not have a single
default python version.

Enforces a minimum python version of 3.12.

Reviewed By: brittanyrey

Differential Revision: D107935421

fbshipit-source-id: bd66f43346fe12d2399aceccde4684ba456a48a0

Author: martindemello

src/commands/analyze.rs

@@ -15,7 +15,9 @@ use pyrefly_python::module_name::ModuleName;
 use tracing::info;
 
 use crate::debug::report_peak_memory;
+use crate::runner::DEFAULT_PYTHON_VERSION;
 use crate::runner::Options;
+use crate::runner::parse_python_version;
 use crate::runner::process_source_map;
 use crate::source_map;
 use crate::tracing::ProcessTimer;
@@ -55,6 +57,10 @@ pub struct AnalyzeArgs {
     /// Name of the main module (the module run as __main__)
     #[arg(long = "main-module")]
     pub main_module: Option<String>,
+
+    /// Python version to use for parsing
+    #[arg(long = "python-version", default_value = DEFAULT_PYTHON_VERSION)]
+    pub python_version: String,
 }
 
 pub fn run(args: AnalyzeArgs) -> Result<()> {
@@ -78,10 +84,13 @@ pub fn run(args: AnalyzeArgs) -> Result<()> {
         None => std::env::current_dir()?,
     };
 
+    let python_version = parse_python_version(&args.python_version)?;
+
     let options = Options {
         verbose_output_path: args.verbose_output_path,
         sorted_output: args.sorted_output,
         main_module: args.main_module.map(|s| ModuleName::from_str(&s)),
+        python_version,
     };
 
     let lifeguard_output = process_source_map(src_map, &root_dir, &options)?;

src/commands/analyze_binary.rs

@@ -18,7 +18,9 @@ use tracing::info;
 use crate::cache::LibraryCache;
 use crate::debug::report_peak_memory;
 use crate::output::LifeGuardAnalysis;
+use crate::runner::DEFAULT_PYTHON_VERSION;
 use crate::runner::Options;
+use crate::runner::parse_python_version;
 use crate::tracing::ProcessTimer;
 use crate::tracing::time;
 
@@ -38,6 +40,10 @@ pub struct AnalyzeBinaryArgs {
     /// Name of the main module (the module run as __main__)
     #[arg(long = "main-module")]
     pub main_module: Option<String>,
+
+    /// Python version to use for parsing
+    #[arg(long = "python-version", default_value = DEFAULT_PYTHON_VERSION)]
+    pub python_version: String,
 }
 
 pub fn run(args: AnalyzeBinaryArgs) -> Result<()> {
@@ -68,10 +74,13 @@ pub fn run(args: AnalyzeBinaryArgs) -> Result<()> {
 
     info!("Merged cache: {} modules", merged.modules.len());
 
+    let python_version = parse_python_version(&args.python_version)?;
+
     let options = Options {
         verbose_output_path: None,
         sorted_output: args.sorted_output,
         main_module: args.main_module.map(|s| ModuleName::from_str(&s)),
+        python_version,
     };
 
     let analysis = time("Building analysis from cache", || {

src/commands/analyze_library.rs

@@ -16,6 +16,9 @@ use tracing::warn;
 use crate::cache::LibraryCache;
 use crate::debug::report_peak_memory;
 use crate::project::CachingMode;
+use crate::runner::DEFAULT_PYTHON_VERSION;
+use crate::runner::Options;
+use crate::runner::parse_python_version;
 use crate::runner::run_pipeline;
 use crate::source_map;
 use crate::source_map::SourceMap;
@@ -35,6 +38,10 @@ pub struct AnalyzeLibraryArgs {
     /// Cross-library resolution is handled entirely in the reduce step (analyze-binary).
     #[arg(long = "dep-cache", hide = true)]
     pub dep_caches: Vec<PathBuf>,
+
+    /// Python version to use for parsing
+    #[arg(long = "python-version", default_value = DEFAULT_PYTHON_VERSION)]
+    pub python_version: String,
 }
 
 /// Detect the root directory by walking up from cwd until a source file resolves.
@@ -91,13 +98,22 @@ pub fn run(args: AnalyzeLibraryArgs) -> Result<()> {
         source_map::load_source_map(&args.db_path)
     })?;
 
+    let python_version = parse_python_version(&args.python_version)?;
+
+    let options = Options {
+        verbose_output_path: None,
+        sorted_output: false,
+        main_module: None,
+        python_version,
+    };
+
     let cache = if src_map.is_empty() {
         info!("Source map is empty, producing empty cache");
         LibraryCache::empty()
     } else {
         let root_dir = detect_root_dir(&src_map)?;
 
-        let result = run_pipeline(src_map, &root_dir, CachingMode::Enabled, None)?;
+        let result = run_pipeline(src_map, &root_dir, CachingMode::Enabled, &options)?;
 
         time("Building cache", || {
             LibraryCache::build(

src/commands/gen_source_db.rs

@@ -15,6 +15,8 @@ use clap::Parser;
 use serde::Serialize;
 
 use crate::find_sources::build_source_db;
+use crate::runner::DEFAULT_PYTHON_VERSION;
+use crate::runner::parse_python_version;
 
 #[derive(Parser)]
 pub struct GenSourceDbArgs {
@@ -27,6 +29,10 @@ pub struct GenSourceDbArgs {
     /// Path to site-packages directory (overrides pyproject.toml setting)
     #[arg(long)]
     site_packages: Option<PathBuf>,
+
+    /// Python version to use for parsing
+    #[arg(long = "python-version", default_value = DEFAULT_PYTHON_VERSION)]
+    python_version: String,
 }
 
 #[derive(Serialize)]
@@ -35,7 +41,12 @@ struct SourceDb {
 }
 
 pub fn run(args: GenSourceDbArgs) -> Result<()> {
-    let (build_map, seed_count) = build_source_db(&args.input_dir, args.site_packages.as_deref())?;
+    let python_version = parse_python_version(&args.python_version)?;
+    let (build_map, seed_count) = build_source_db(
+        &args.input_dir,
+        args.site_packages.as_deref(),
+        python_version,
+    )?;
     eprintln!(
         "Seeded with {} files from {}",
         seed_count,

src/commands/run_tree.rs

@@ -15,7 +15,9 @@ use pyrefly_python::module_name::ModuleName;
 
 use crate::find_sources::build_source_db;
 use crate::find_sources::make_source_map;
+use crate::runner::DEFAULT_PYTHON_VERSION;
 use crate::runner::Options;
+use crate::runner::parse_python_version;
 use crate::runner::process_source_map;
 use crate::tracing::ProcessTimer;
 use crate::tracing::time;
@@ -46,14 +48,24 @@ pub struct RunTreeArgs {
     /// Name of the main module (the module run as __main__)
     #[arg(long = "main-module")]
     main_module: Option<String>,
+
+    /// Python version to use for parsing
+    #[arg(long = "python-version", default_value = DEFAULT_PYTHON_VERSION)]
+    python_version: String,
 }
 
 pub fn run(args: RunTreeArgs) -> Result<()> {
     let timer = ProcessTimer::new();
     let cwd = std::env::current_dir()?;
 
+    let python_version = parse_python_version(&args.python_version)?;
+
     let (build_map, _) = time("Discovering sources", || {
-        build_source_db(&args.input_dir, args.site_packages.as_deref())
+        build_source_db(
+            &args.input_dir,
+            args.site_packages.as_deref(),
+            python_version,
+        )
     })?;
     println!("Found {} Python files", build_map.len());
 
@@ -63,6 +75,7 @@ pub fn run(args: RunTreeArgs) -> Result<()> {
         verbose_output_path: args.verbose_output_path,
         sorted_output: args.sorted_output,
         main_module: args.main_module.map(|s| ModuleName::from_str(&s)),
+        python_version,
     };
 
     let lifeguard_output = process_source_map(source_map, &cwd, &options)?;

src/commands/show_effects.rs

@@ -17,29 +17,37 @@ use crate::debug::print_module_imports_map;
 use crate::imports::ImportGraph;
 use crate::module_parser;
 use crate::pyrefly::module_name::ModuleName;
+use crate::runner::DEFAULT_PYTHON_VERSION;
+use crate::runner::parse_python_version;
 use crate::source_map::ModuleProvider;
 use crate::test_lib::TestSources;
 
 #[derive(Parser)]
 pub struct ShowEffectsArgs {
     input_file: PathBuf,
+
+    /// Python version to use for parsing
+    #[arg(long = "python-version", default_value = DEFAULT_PYTHON_VERSION)]
+    python_version: String,
 }
 
 pub fn run(args: ShowEffectsArgs) -> Result<()> {
     let module_name = ModuleName::from_str("current_module");
     let path = args.input_file;
     let source = std::fs::read_to_string(&path)?;
 
+    let python_version = parse_python_version(&args.python_version)?;
+    let config = AnalysisConfig::with_python_version(python_version, None);
+
     let sources = TestSources::new(&[("current_module", &source)]);
-    let config = AnalysisConfig::default();
     let (import_graph, exports) = ImportGraph::make_with_exports(&sources, &config);
 
-    // Run the analysis
     let typ = module_parser::file_source_type(&path).unwrap();
     let is_init = path
         .file_name()
         .is_some_and(|f| f == "__init__.py" || f == "__init__.pyi");
-    let module = module_parser::parse_file(&source, typ, module_name, is_init);
+    let module =
+        module_parser::parse_file_with_version(&source, typ, module_name, is_init, python_version);
     let output = analyzer::analyze(&module, &exports, &import_graph, sources.stubs(), &config);
 
     // Display output

src/config.rs

@@ -11,6 +11,7 @@ use ruff_python_ast::Expr;
 use ruff_python_ast::Stmt;
 use ruff_python_ast::StmtIf;
 
+use crate::pyrefly::sys_info::PythonVersion;
 use crate::pyrefly::sys_info::SysInfo;
 use crate::traits::SysInfoExt;
 
@@ -64,6 +65,16 @@ impl AnalysisConfig {
         }
     }
 
+    pub fn with_python_version(
+        python_version: PythonVersion,
+        main_module: Option<ModuleName>,
+    ) -> Self {
+        Self {
+            sys_info: SysInfo::lg_with_version(python_version),
+            main_module,
+        }
+    }
+
     pub fn lg_pruned_if_branches<'a>(
         &'a self,
         x: &'a StmtIf,

src/find_sources.rs

@@ -20,10 +20,12 @@ use std::path::PathBuf;
 use anyhow::Context;
 use anyhow::Result;
 use ruff_python_ast::Stmt;
-use ruff_python_parser::parse_unchecked_source;
+use ruff_python_parser::ParseOptions;
 use serde::Deserialize;
 use walkdir::WalkDir;
 
+use crate::pyrefly::sys_info::PythonVersion;
+use crate::runner::to_ruff_version;
 use crate::source_map::RawSourceMap;
 use crate::source_map::SourceMap;
 use crate::source_map::is_python_file;
@@ -121,11 +123,22 @@ fn resolve_relative_import(level: u32, module: Option<&str>, package: &str) -> O
 
 /// Extract dotted module names from import statements in Python source.
 /// If `package` is provided, relative imports are resolved against it.
-fn extract_imports(source: &str, package: Option<&str>) -> Vec<String> {
-    let parsed = parse_unchecked_source(source, ruff_python_ast::PySourceType::Python);
+fn extract_imports(
+    source: &str,
+    package: Option<&str>,
+    python_version: PythonVersion,
+) -> Vec<String> {
+    let ruff_version = to_ruff_version(&python_version);
+    let options =
+        ParseOptions::from(ruff_python_ast::PySourceType::Python).with_target_version(ruff_version);
+    let parsed = ruff_python_parser::parse_unchecked(source, options);
     let mut imports = Vec::new();
+    let module = match parsed.into_syntax() {
+        ruff_python_ast::Mod::Module(m) => m,
+        _ => return Vec::new(),
+    };
 
-    for stmt in parsed.suite() {
+    for stmt in module.body {
         match stmt {
             Stmt::Import(import) => {
                 for alias in &import.names {
@@ -209,6 +222,7 @@ fn load_site_packages(input_dir: &Path) -> Result<Option<PathBuf>> {
 pub fn build_source_db(
     input_dir: &Path,
     site_packages_override: Option<&Path>,
+    python_version: PythonVersion,
 ) -> Result<(BTreeMap<String, String>, usize)> {
     let input_dir = input_dir.canonicalize()?;
 
@@ -284,7 +298,7 @@ pub fn build_source_db(
             .as_ref()
             .and_then(|sp| file_path.strip_prefix(sp).ok())
             .and_then(package_from_rel_path);
-        let imports = extract_imports(&source, package.as_deref());
+        let imports = extract_imports(&source, package.as_deref(), python_version);
         for module_name in imports {
             if let Some(resolved) = resolve_import(&roots, &module_name) {
                 let resolved = match resolved.canonicalize() {

src/format.rs

@@ -294,15 +294,30 @@ fn format_comprehensions(generators: &[ruff_python_ast::Comprehension]) -> Strin
 
 #[cfg(test)]
 mod tests {
+    use ruff_python_ast::ModModule;
     use ruff_python_ast::PySourceType;
-    use ruff_python_parser::parse_unchecked_source;
+    use ruff_python_parser::ParseOptions;
 
     use super::*;
+    use crate::runner::default_ruff_version;
+
+    fn parse_module(source: &str) -> ModModule {
+        let options =
+            ParseOptions::from(PySourceType::Python).with_target_version(default_ruff_version());
+        let parsed = ruff_python_parser::parse_unchecked(source, options);
+        match parsed.into_syntax() {
+            ruff_python_ast::Mod::Module(m) => m,
+            _ => panic!("Expected module"),
+        }
+    }
 
     fn parse_expr(source: &str) -> Expr {
-        let parsed = parse_unchecked_source(source, PySourceType::Python);
-        let module = parsed.into_syntax();
-        match module.body.into_iter().next().expect("empty module") {
+        match parse_module(source)
+            .body
+            .into_iter()
+            .next()
+            .expect("empty module")
+        {
             ruff_python_ast::Stmt::Expr(stmt) => *stmt.value,
             other => panic!("Expected expression statement, got {:?}", other),
         }
@@ -440,9 +455,7 @@ mod tests {
     #[test]
     fn test_await() {
         // Parse inside an async function to make it valid
-        let source = "async def f():\n await x";
-        let parsed = parse_unchecked_source(source, PySourceType::Python);
-        let module = parsed.into_syntax();
+        let module = parse_module("async def f():\n await x");
         let func = match &module.body[0] {
             ruff_python_ast::Stmt::FunctionDef(f) => f,
             other => panic!("Expected FunctionDef, got {:?}", other),