Add tests for case-sensitive module resolution

Author: MichaReiser

crates/red_knot_python_semantic/resources/mdtest/import/case_sensitive.md

@@ -0,0 +1,126 @@
+# Case Sensitive Imports
+
+TODO: This test should use the real file system instead of the memory file system.
+
+Python's import system is case-sensitive even on case-insensitive file system. This means, importing
+a module `a` should fail if the file in the search paths is named `A.py`. See
+[PEP 235](https://peps.python.org/pep-0235/).
+
+## Correct casing
+
+Importing a module where the name matches the file name's casing should succeed.
+
+`a.py`:
+
+```py
+class A:
+    x: int = 1
+```
+
+```python
+from a import A
+
+reveal_type(A().x)  # revealed: int
+```
+
+## Incorrect casing
+
+Importing a module where the name does not match the file name's casing should fail.
+
+`A.py`:
+
+```py
+class A:
+    x: int = 1
+```
+
+```python
+# error: [unresolved-import]
+from a import A
+```
+
+## Multiple search paths with different cased modules
+
+The resolved module is the first matching the file name's casing but Python falls back to later
+search paths if the file name's casing does not match.
+
+```toml
+[environment]
+extra-paths = ["/search-1", "/search-2"]
+```
+
+`/search-1/A.py`:
+
+```py
+class A:
+    x: int = 1
+```
+
+`/search-2/a.py`:
+
+```py
+class A:
+    x: str = "test"
+```
+
+```python
+from a import A as ALower
+from A import A as AUpper
+
+reveal_type(AUpper().x)  # revealed: int
+reveal_type(ALower().x)  # revealed: str
+```
+
+## Intermediate segments
+
+`db/__init__.py`:
+
+```py
+```
+
+`db/a.py`:
+
+```py
+class A:
+    x: int = 1
+```
+
+`correctly_cased.py`:
+
+```python
+from db.a import A
+
+reveal_type(A().x)  # revealed: int
+```
+
+Imports where some segments are incorrectly cased should fail.
+
+`incorrectly_cased.py`:
+
+```python
+# error: [unresolved-import]
+from DB.a import A
+
+# error: [unresolved-import]
+from DB.A import A
+
+# error: [unresolved-import]
+from db.A import A
+```
+
+## Incorrectly extension casing
+
+The extension of imported python modules must be `.py` or `.pyi` but not `.PY` or `Py` or any
+variant where some characters are uppercase.
+
+`a.PY`:
+
+```py
+class A:
+    x: int = 1
+```
+
+```python
+# error: [unresolved-import]
+from a import A
+```

crates/red_knot_test/src/config.rs

@@ -10,6 +10,7 @@
 
 use anyhow::Context;
 use red_knot_python_semantic::PythonPlatform;
+use ruff_db::system::{SystemPath, SystemPathBuf};
 use ruff_python_ast::PythonVersion;
 use serde::Deserialize;
 
@@ -36,11 +37,17 @@ impl MarkdownTestConfig {
             .and_then(|env| env.python_platform.clone())
     }
 
-    pub(crate) fn typeshed(&self) -> Option<&str> {
+    pub(crate) fn typeshed(&self) -> Option<&SystemPath> {
         self.environment
             .as_ref()
             .and_then(|env| env.typeshed.as_deref())
     }
+
+    pub(crate) fn extra_paths(&self) -> Option<&[SystemPathBuf]> {
+        self.environment
+            .as_ref()
+            .and_then(|env| env.extra_paths.as_deref())
+    }
 }
 
 #[derive(Deserialize, Debug, Default, Clone)]
@@ -53,7 +60,10 @@ pub(crate) struct Environment {
     pub(crate) python_platform: Option<PythonPlatform>,
 
     /// Path to a custom typeshed directory.
-    pub(crate) typeshed: Option<String>,
+    pub(crate) typeshed: Option<SystemPathBuf>,
+
+    /// Additional search paths to consider when resolving modules.
+    pub(crate) extra_paths: Option<Vec<SystemPathBuf>>,
 }
 
 #[derive(Deserialize, Debug, Clone)]

crates/red_knot_test/src/lib.rs

@@ -9,7 +9,7 @@ use ruff_db::diagnostic::{Diagnostic, DisplayDiagnosticConfig, ParseDiagnostic};
 use ruff_db::files::{system_path_to_file, File, Files};
 use ruff_db::panic::catch_unwind;
 use ruff_db::parsed::parsed_module;
-use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
+use ruff_db::system::{DbWithTestSystem, SystemPath, SystemPathBuf};
 use ruff_db::testing::{setup_logging, setup_logging_with_filter};
 use ruff_source_file::{LineIndex, OneIndexed};
 use std::fmt::Write;
@@ -106,7 +106,7 @@ fn run_test(
 ) -> Result<(), Failures> {
     let project_root = db.project_root().to_path_buf();
     let src_path = SystemPathBuf::from("/src");
-    let custom_typeshed_path = test.configuration().typeshed().map(SystemPathBuf::from);
+    let custom_typeshed_path = test.configuration().typeshed().map(SystemPath::to_path_buf);
     let mut typeshed_files = vec![];
     let mut has_custom_versions_file = false;
 
@@ -118,11 +118,11 @@ fn run_test(
             }
 
             assert!(
-                matches!(embedded.lang, "py" | "pyi" | "text"),
+                matches!(embedded.lang, "py" | "pyi" | "python" | "text"),
                 "Supported file types are: py, pyi, text"
             );
 
-            let full_path = embedded.full_path(&project_root);
+            let full_path = SystemPath::absolute(embedded.relative_path(), &project_root);
 
             if let Some(ref typeshed_path) = custom_typeshed_path {
                 if let Ok(relative_path) = full_path.strip_prefix(typeshed_path.join("stdlib")) {
@@ -178,7 +178,11 @@ fn run_test(
                 python_platform: test.configuration().python_platform().unwrap_or_default(),
                 search_paths: SearchPathSettings {
                     src_roots: vec![src_path],
-                    extra_paths: vec![],
+                    extra_paths: test
+                        .configuration()
+                        .extra_paths()
+                        .unwrap_or_default()
+                        .to_vec(),
                     custom_typeshed: custom_typeshed_path,
                     python_path: PythonPath::KnownSitePackages(vec![]),
                 },

crates/red_knot_test/src/parser.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, collections::hash_map::Entry};
 
 use anyhow::bail;
-use ruff_db::system::{SystemPath, SystemPathBuf};
+use ruff_db::system::SystemPath;
 use rustc_hash::FxHashMap;
 
 use ruff_index::{newtype_index, IndexVec};
@@ -282,15 +282,6 @@ impl EmbeddedFile<'_> {
     pub(crate) fn relative_path(&self) -> &str {
         self.path.as_str()
     }
-
-    pub(crate) fn full_path(&self, project_root: &SystemPath) -> SystemPathBuf {
-        let relative_path = self.relative_path();
-        if relative_path.starts_with('/') {
-            SystemPathBuf::from(relative_path)
-        } else {
-            project_root.join(relative_path)
-        }
-    }
 }
 
 #[derive(Debug)]
@@ -606,10 +597,13 @@ impl<'s> Parser<'s> {
         }
 
         if let Some(explicit_path) = self.explicit_path {
-            if !lang.is_empty()
+            let expected_extension = if lang == "python" { "py" } else { lang };
+
+            if !expected_extension.is_empty()
                 && lang != "text"
-                && explicit_path.contains('.')
-                && !explicit_path.ends_with(&format!(".{lang}"))
+                && !SystemPath::new(explicit_path)
+                    .extension()
+                    .is_none_or(|extension| extension.eq_ignore_ascii_case(expected_extension))
             {
                 bail!(
                     "File extension of test file path `{explicit_path}` in test `{test_name}` does not match language specified `{lang}` of code block"