Red-knot no longer panics!

Author: AlexWaygood

crates/red_knot_project/src/lib.rs

@@ -8,7 +8,7 @@ pub use metadata::{ProjectDiscoveryError, ProjectMetadata};
 use red_knot_python_semantic::lint::{LintRegistry, LintRegistryBuilder, RuleSelection};
 use red_knot_python_semantic::syntax::SyntaxDiagnostic;
 use red_knot_python_semantic::types::check_types;
-use red_knot_python_semantic::{python_version, register_lints};
+use red_knot_python_semantic::{Program, register_lints};
 use ruff_db::diagnostic::{Diagnostic, DiagnosticId, ParseDiagnostic, Severity, Span};
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::parsed::parsed_module;
@@ -334,7 +334,7 @@ fn check_file_impl(db: &dyn Db, file: File) -> Vec<Box<dyn Diagnostic>> {
         return diagnostics;
     }
 
-    let parsed = parsed_module(db.upcast(), file, python_version(db.upcast()));
+    let parsed = parsed_module(db.upcast(), file, Program::get(db).python_version(db));
     diagnostics.extend(parsed.errors().iter().map(|error| {
         let diagnostic: Box<dyn Diagnostic> = Box::new(ParseDiagnostic::new(file, error.clone()));
         diagnostic

crates/red_knot_project/tests/check.rs

@@ -1,6 +1,6 @@
 use anyhow::{anyhow, Context};
 use red_knot_project::{ProjectDatabase, ProjectMetadata};
-use red_knot_python_semantic::{python_version, HasType, SemanticModel};
+use red_knot_python_semantic::{Program, HasType, SemanticModel};
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::parsed::parsed_module;
 use ruff_db::system::{SystemPath, SystemPathBuf, TestSystem};
@@ -165,7 +165,7 @@ fn run_corpus_tests(pattern: &str) -> anyhow::Result<()> {
 fn pull_types(db: &ProjectDatabase, file: File) {
     let mut visitor = PullTypesVisitor::new(db, file);
 
-    let ast = parsed_module(db, file, python_version(db));
+    let ast = parsed_module(db, file, Program::get(db).python_version(db));
 
     visitor.visit_body(ast.suite());
 }

crates/red_knot_python_semantic/src/lib.rs

@@ -50,12 +50,3 @@ pub fn register_lints(registry: &mut LintRegistryBuilder) {
     registry.register_lint(&UNKNOWN_RULE);
     registry.register_lint(&INVALID_IGNORE_COMMENT);
 }
-
-// TODO(brent) remove this. It should just be `Program::get(db).python_version(db)`, but for some
-// reason `tests::check_file_skips_type_checking_when_file_cant_be_read` fails when I use `get`, so
-// I factored this out instead of inlining everywhere
-pub fn python_version(db: &dyn Db) -> ruff_python_ast::PythonVersion {
-    Program::try_get(db)
-        .map(|program| program.python_version(db))
-        .unwrap_or_default()
-}

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -5,7 +5,6 @@ use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
 use ruff_index::{IndexSlice, IndexVec};
 
-use ruff_python_ast::PythonVersion;
 use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
 use salsa::plumbing::AsId;
 use salsa::Update;
@@ -21,7 +20,7 @@ use crate::semantic_index::symbol::{
     FileScopeId, NodeWithScopeKey, NodeWithScopeRef, Scope, ScopeId, ScopedSymbolId, SymbolTable,
 };
 use crate::semantic_index::use_def::{EagerBindingsKey, ScopedEagerBindingsId, UseDefMap};
-use crate::Db;
+use crate::{Db, Program};
 
 pub mod ast_ids;
 pub mod attribute_assignment;
@@ -46,13 +45,7 @@ type SymbolMap = hashbrown::HashMap<ScopedSymbolId, (), FxBuildHasher>;
 pub(crate) fn semantic_index(db: &dyn Db, file: File) -> SemanticIndex<'_> {
     let _span = tracing::trace_span!("semantic_index", file = %file.path(db)).entered();
 
-    // TODO(brent) need to pass the real PythonVersion here, but tests fail when I change it from
-    // PythonVersion::default()
-    //
-    // I've tried my hacky `python_version` helper function and also
-    // `Program::get(db).python_version(db)`, and many tests fail in both cases (18 with
-    // `python_version`, 48 with `Program::get`)
-    let parsed = parsed_module(db.upcast(), file, PythonVersion::default());
+    let parsed = parsed_module(db.upcast(), file, Program::get(db).python_version(db));
 
     SemanticIndexBuilder::new(db, file, parsed).build()
 }
@@ -415,11 +408,10 @@ impl FusedIterator for ChildrenIter<'_> {}
 mod tests {
     use ruff_db::files::{system_path_to_file, File};
     use ruff_db::parsed::parsed_module;
-    use ruff_db::system::DbWithTestSystem;
     use ruff_python_ast::{self as ast, PythonVersion};
     use ruff_text_size::{Ranged, TextRange};
 
-    use crate::db::tests::TestDb;
+    use crate::db::tests::{TestDb, TestDbBuilder};
     use crate::semantic_index::ast_ids::{HasScopedUseId, ScopedUseId};
     use crate::semantic_index::definition::{Definition, DefinitionKind};
     use crate::semantic_index::symbol::{
@@ -447,10 +439,14 @@ mod tests {
     }
 
     fn test_case(content: impl ToString) -> TestCase {
-        let mut db = TestDb::new();
-        db.write_file("test.py", content).unwrap();
+        const FILENAME: &str = "test.py";
 
-        let file = system_path_to_file(&db, "test.py").unwrap();
+        let db = TestDbBuilder::new()
+            .with_file(FILENAME, &content.to_string())
+            .build()
+            .unwrap();
+
+        let file = system_path_to_file(&db, FILENAME).unwrap();
 
         TestCase { db, file }
     }

crates/red_knot_python_semantic/src/suppression.rs

@@ -1,6 +1,6 @@
 use crate::lint::{GetLintError, Level, LintMetadata, LintRegistry, LintStatus};
-use crate::python_version;
 use crate::types::{TypeCheckDiagnostic, TypeCheckDiagnostics};
+use crate::Program;
 use crate::{declare_lint, lint::LintId, Db};
 use ruff_db::diagnostic::DiagnosticId;
 use ruff_db::{files::File, parsed::parsed_module, source::source_text};
@@ -89,7 +89,7 @@ declare_lint! {
 
 #[salsa::tracked(return_ref)]
 pub(crate) fn suppressions(db: &dyn Db, file: File) -> Suppressions {
-    let parsed = parsed_module(db.upcast(), file, python_version(db));
+    let parsed = parsed_module(db.upcast(), file, Program::get(db).python_version(db));
     let source = source_text(db.upcast(), file);
 
     let mut builder = SuppressionsBuilder::new(&source, db.lint_registry());

crates/red_knot_python_semantic/src/types.rs

@@ -4617,7 +4617,7 @@ pub(crate) mod tests {
         );
         let events = db.take_salsa_events();
 
-        let call = &*parsed_module(&db, bar, PythonVersion::default())
+        let call = &*parsed_module(&db, bar, Program::get(&db).python_version(&db))
             .syntax()
             .body[1]
             .as_assign_stmt()

crates/red_knot_python_semantic/src/types/infer.rs

@@ -32,7 +32,7 @@ use itertools::{Either, Itertools};
 use ruff_db::diagnostic::{DiagnosticId, Severity};
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
-use ruff_python_ast::{self as ast, AnyNodeRef, ExprContext, PythonVersion};
+use ruff_python_ast::{self as ast, AnyNodeRef, ExprContext};
 use ruff_text_size::Ranged;
 use rustc_hash::{FxHashMap, FxHashSet};
 use salsa;
@@ -76,7 +76,7 @@ use crate::types::{
 };
 use crate::unpack::Unpack;
 use crate::util::subscript::{PyIndex, PySlice};
-use crate::Db;
+use crate::{Db, Program};
 
 use super::call::CallError;
 use super::context::{InNoTypeCheck, InferContext, WithDiagnostics};
@@ -507,17 +507,15 @@ impl<'db> TypeInferenceBuilder<'db> {
     }
 
     fn infer_region_scope(&mut self, scope: ScopeId<'db>) {
-        let node = scope.node(self.db());
+        let db = self.db();
+        let node = scope.node(db);
         match node {
             NodeWithScopeKind::Module => {
-                // TODO(brent) need to pass the real PythonVersion here, but tests fail when I
-                // change it from PythonVersion::default()
-                //
-                // I've tried my hacky `python_version` helper function and also
-                // `Program::get(db).python_version(db)`, and many tests fail in both cases (18 with
-                // `python_version`, 19 with `Program::get`)
-                let parsed =
-                    parsed_module(self.db().upcast(), self.file(), PythonVersion::default());
+                let parsed = parsed_module(
+                    db.upcast(),
+                    self.file(),
+                    Program::get(db).python_version(db),
+                );
                 self.infer_module(parsed.syntax());
             }
             NodeWithScopeKind::Function(function) => self.infer_function_body(function.node()),
@@ -552,7 +550,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         // Infer the deferred types for the definitions here to consider the end-of-scope
         // semantics.
         for definition in std::mem::take(&mut self.types.deferred) {
-            self.extend(infer_deferred_types(self.db(), definition));
+            self.extend(infer_deferred_types(db, definition));
         }
         assert!(
             self.types.deferred.is_empty(),

crates/red_knot_test/src/assertion.rs

@@ -35,7 +35,7 @@
 //! ```
 
 use crate::db::Db;
-use red_knot_python_semantic::python_version;
+use red_knot_python_semantic::Program;
 use regex::Regex;
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
@@ -59,7 +59,7 @@ impl InlineFileAssertions {
     pub(crate) fn from_file(db: &Db, file: File) -> Self {
         let source = source_text(db, file);
         let lines = line_index(db, file);
-        let parsed = parsed_module(db, file, python_version(db));
+        let parsed = parsed_module(db, file, Program::get(db).python_version(db));
         let comment_ranges = CommentRanges::from(parsed.tokens());
         Self {
             comment_ranges,

crates/red_knot_test/src/lib.rs

@@ -4,9 +4,7 @@ use camino::Utf8Path;
 use colored::Colorize;
 use parser as test_parser;
 use red_knot_python_semantic::types::check_types;
-use red_knot_python_semantic::{
-    python_version, Program, ProgramSettings, SearchPathSettings, SitePackages,
-};
+use red_knot_python_semantic::{Program, ProgramSettings, SearchPathSettings, SitePackages};
 use ruff_db::diagnostic::{Diagnostic, DisplayDiagnosticConfig, ParseDiagnostic};
 use ruff_db::files::{system_path_to_file, File, Files};
 use ruff_db::panic::catch_unwind;
@@ -195,7 +193,7 @@ fn run_test(
     let failures: Failures = test_files
         .into_iter()
         .filter_map(|test_file| {
-            let parsed = parsed_module(db, test_file.file, python_version(db));
+            let parsed = parsed_module(db, test_file.file, Program::get(db).python_version(db));
 
             let mut diagnostics: Vec<Box<_>> = parsed
                 .errors()

crates/red_knot_wasm/src/lib.rs

@@ -1,13 +1,13 @@
 use std::any::Any;
 
 use js_sys::Error;
-use red_knot_python_semantic::python_version;
 use wasm_bindgen::prelude::*;
 
 use red_knot_project::metadata::options::{EnvironmentOptions, Options};
 use red_knot_project::metadata::value::RangedValue;
 use red_knot_project::ProjectMetadata;
 use red_knot_project::{Db, ProjectDatabase};
+use red_knot_python_semantic::Program;
 use ruff_db::diagnostic::{Diagnostic, DisplayDiagnosticConfig};
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
@@ -135,16 +135,22 @@ impl Workspace {
 
     /// Returns the parsed AST for `path`
     pub fn parsed(&self, file_id: &FileHandle) -> Result<String, Error> {
-        let parsed =
-            ruff_db::parsed::parsed_module(&self.db, file_id.file, python_version(&self.db));
+        let parsed = ruff_db::parsed::parsed_module(
+            &self.db,
+            file_id.file,
+            Program::get(&self.db).python_version(&self.db),
+        );
 
         Ok(format!("{:#?}", parsed.syntax()))
     }
 
     /// Returns the token stream for `path` serialized as a string.
     pub fn tokens(&self, file_id: &FileHandle) -> Result<String, Error> {
-        let parsed =
-            ruff_db::parsed::parsed_module(&self.db, file_id.file, python_version(&self.db));
+        let parsed = ruff_db::parsed::parsed_module(
+            &self.db,
+            file_id.file,
+            Program::get(&self.db).python_version(&self.db),
+        );
 
         Ok(format!("{:#?}", parsed.tokens()))
     }