superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty-type-checking/src/type_check.rs

@@ -0,0 +1,280 @@
+use std::{
+    fmt::{self, Display},
+    sync::{Arc, Mutex},
+};
+
+use ruff_db::{
+    Db as SourceDb,
+    diagnostic::{
+        Annotation, Diagnostic, DiagnosticFormat, DiagnosticId, DisplayDiagnosticConfig, DisplayDiagnostics,
+        UnifiedFile,
+    },
+    files::{File, FileRootKind, system_path_to_file},
+    system::{DbWithWritableSystem as _, SystemPathBuf},
+};
+use ruff_text_size::{TextRange, TextSize};
+use ty_module_resolver::SearchPathSettings;
+use ty_python_semantic::{
+    Program, ProgramSettings, PythonPlatform, PythonVersionSource, PythonVersionWithSource, types::check_types,
+};
+
+use crate::db::MemoryDb;
+
+/// Definition of a source file.
+pub struct SourceFile<'a> {
+    /// source code
+    pub source_code: &'a str,
+    /// file path
+    pub path: &'a str,
+}
+
+impl<'a> SourceFile<'a> {
+    /// Create a new source file.
+    #[must_use]
+    pub fn new(source_code: &'a str, path: &'a str) -> Self {
+        Self { source_code, path }
+    }
+}
+
+/// Type check some python source code, checking if it's valid to run with monty.
+///
+/// # Arguments
+/// * `python_source` - The python source code to type check.
+/// * `stubs_file` - Optional stubs file to use for type checking.
+///
+/// # Returns
+/// * `Ok(Some(TypeCheckingFailure))` - If there are typing errors.
+/// * `Ok(None)` - If there are no typing errors.
+/// * `Err(String)` - If there was an unexpected/internal error during type checking.
+pub fn type_check(
+    python_source: &SourceFile<'_>,
+    stubs_file: Option<&SourceFile<'_>>,
+) -> Result<Option<TypeCheckingDiagnostics>, String> {
+    let mut db = MemoryDb::new();
+
+    // Files must be written under a directory that's registered as a search path for module
+    // resolution to work. We use "/" as the root directory so paths appear without a prefix.
+    let src_root = SystemPathBuf::from("/");
+
+    // Register the source root for Salsa tracking - required for module resolution
+    db.files().try_add_root(&db, &src_root, FileRootKind::Project);
+
+    let search_paths = SearchPathSettings::new(vec![src_root.clone()])
+        .to_search_paths(db.system(), db.vendored())
+        .map_err(to_string)?;
+
+    // The API is confusing here - we have to load the "program" here like this, otherwise we get unwrap
+    // panics when calling `check_types`
+    Program::from_settings(
+        &db,
+        ProgramSettings {
+            python_version: PythonVersionWithSource {
+                version: db.python_version(),
+                source: PythonVersionSource::default(),
+            },
+            python_platform: PythonPlatform::default(),
+            search_paths,
+        },
+    );
+
+    // Build absolute paths for files under /
+    let main_path = src_root.join(python_source.path);
+    let main_source = python_source.source_code;
+
+    let code_offset: u32 = if let Some(stubs_file) = stubs_file {
+        let stubs_path = src_root.join(stubs_file.path);
+
+        // write the stub file
+        db.write_file(&stubs_path, stubs_file.source_code).map_err(to_string)?;
+
+        // prepend the stub import to the main source code
+        let stub_stem = stubs_file
+            .path
+            .split_once('.')
+            .map_or(stubs_file.path, |(before, _)| before);
+        let mut new_source = format!("from {stub_stem} import *\n");
+        let offset = u32::try_from(new_source.len()).map_err(to_string)?;
+        new_source.push_str(main_source);
+
+        // write the main source code
+        db.write_file(&main_path, &new_source).map_err(to_string)?;
+        // one line offset for errors vs. the original source code since we injected the stub import
+        offset
+    } else {
+        // write just the main source code
+        db.write_file(&main_path, main_source).map_err(to_string)?;
+        0
+    };
+
+    let main_file = system_path_to_file(&db, &main_path).map_err(to_string)?;
+    let mut diagnostics = check_types(&db, main_file);
+    diagnostics.retain(filter_diagnostics);
+
+    if diagnostics.is_empty() {
+        Ok(None)
+    } else {
+        // without all this errors would appear on the wrong line because we injected `from type_stubs import *`
+
+        // if we injected the stubs import, we need to write the actual source back to the file in the database
+        db.write_file(&main_path, main_source).map_err(to_string)?;
+        // and then adjust each span in the error message to account for the injected stubs import
+        if code_offset > 0 {
+            let offset = TextSize::new(code_offset);
+            for diagnostic in &mut diagnostics {
+                // Adjust spans in main diagnostic annotations (only for spans in the main file)
+                for ann in diagnostic.annotations_mut() {
+                    adjust_annotation_span(ann, main_file, offset);
+                }
+                // Adjust spans in sub-diagnostic annotations (e.g., "info: Function defined here")
+                for sub in diagnostic.sub_diagnostics_mut() {
+                    for ann in sub.annotations_mut() {
+                        adjust_annotation_span(ann, main_file, offset);
+                    }
+                }
+            }
+        }
+        // Sort diagnostics by line number
+        diagnostics.sort_by(|a, b| a.rendering_sort_key(&db).cmp(&b.rendering_sort_key(&db)));
+
+        Ok(Some(TypeCheckingDiagnostics::new(diagnostics, db)))
+    }
+}
+
+fn to_string(err: impl Display) -> String {
+    err.to_string()
+}
+
+/// Adjust the span of an annotation by subtracting the given offset.
+///
+/// This is used when we inject a stub import at the beginning of the source code,
+/// and need to adjust all spans to account for the injected code.
+/// Only adjusts spans that belong to the main file being type-checked.
+fn adjust_annotation_span(ann: &mut Annotation, main_file: File, offset: TextSize) {
+    let span = ann.get_span();
+    // Only adjust spans for the main file (not stubs or other files)
+    if let UnifiedFile::Ty(span_file) = span.file()
+        && *span_file == main_file
+        && let Some(range) = span.range()
+    {
+        let new_range = TextRange::new(range.start() - offset, range.end() - offset);
+        let new_span = span.clone().with_range(new_range);
+        ann.set_span(new_span);
+    }
+}
+
+/// Represents diagnostic details when type checking fails.
+#[derive(Clone)]
+pub struct TypeCheckingDiagnostics {
+    /// The actual diagnostic message
+    diagnostics: Vec<Diagnostic>,
+    /// db used to display diagnostics, wrapped in Mutex for Sync so MontyTypingError is sendable
+    db: Arc<Mutex<MemoryDb>>,
+    /// How to format the output
+    format: DiagnosticFormat,
+    /// Whether to highlight the output with ansi colors
+    color: bool,
+}
+
+/// Debug output for TypeCheckingDiagnostics shows the pretty typing output, and no other values since
+/// this will be displayed when users are printing `Result<..., TypeCheckingDiagnostics>` etc. and the
+/// raw errors are not useful to end users.
+impl fmt::Debug for TypeCheckingDiagnostics {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let config = self.config();
+        let db = self.db.lock().unwrap();
+        write!(
+            f,
+            "TypeCheckingDiagnostics:\n{}",
+            DisplayDiagnostics::new(&*db, &config, &self.diagnostics)
+        )
+    }
+}
+
+/// To display true debugs details about the TypeCheckingDiagnostics
+#[derive(Debug)]
+#[expect(dead_code)]
+pub struct DebugTypeCheckingDiagnostics<'a> {
+    diagnostics: &'a [Diagnostic],
+    db: Arc<Mutex<MemoryDb>>,
+    format: DiagnosticFormat,
+    color: bool,
+}
+
+impl fmt::Display for TypeCheckingDiagnostics {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let db = self.db.lock().unwrap();
+        DisplayDiagnostics::new(&*db, &self.config(), &self.diagnostics).fmt(f)
+    }
+}
+
+impl TypeCheckingDiagnostics {
+    fn new(diagnostics: Vec<Diagnostic>, db: MemoryDb) -> Self {
+        Self {
+            diagnostics,
+            db: Arc::new(Mutex::new(db)),
+            format: DiagnosticFormat::Full,
+            color: false,
+        }
+    }
+
+    fn config(&self) -> DisplayDiagnosticConfig {
+        DisplayDiagnosticConfig::new("monty")
+            .format(self.format)
+            .color(self.color)
+    }
+
+    /// To display debug details for the TypeCheckingDiagnostics since debug is the pretty output
+    #[must_use]
+    pub fn debug_details(&self) -> DebugTypeCheckingDiagnostics<'_> {
+        DebugTypeCheckingDiagnostics {
+            diagnostics: &self.diagnostics,
+            db: self.db.clone(),
+            format: self.format,
+            color: self.color,
+        }
+    }
+
+    /// Set the format of the diagnostics.
+    #[must_use]
+    pub fn format(self, format: DiagnosticFormat) -> Self {
+        Self { format, ..self }
+    }
+
+    /// Set the format of the diagnostics from a string.
+    /// Valid formats: "full", "concise", "azure", "json", "jsonlines", "rdjson",
+    /// "pylint", "gitlab", "github".
+    pub fn format_from_str(self, format: &str) -> Result<Self, String> {
+        let format = match format.to_ascii_lowercase().as_str() {
+            "full" => DiagnosticFormat::Full,
+            "concise" => DiagnosticFormat::Concise,
+            "azure" => DiagnosticFormat::Azure,
+            "json" => DiagnosticFormat::Json,
+            "jsonlines" | "json-lines" => DiagnosticFormat::JsonLines,
+            "rdjson" => DiagnosticFormat::Rdjson,
+            "pylint" => DiagnosticFormat::Pylint,
+            // don't bother with the "junit" feature, please check the binary size and add it if you need this format
+            // "junit" => DiagnosticFormat::Junit,
+            "gitlab" => DiagnosticFormat::Gitlab,
+            "github" => DiagnosticFormat::Github,
+            _ => return Err(format!("Unknown format: {format}")),
+        };
+        Ok(Self { format, ..self })
+    }
+
+    /// Set whether to highlight the output with ansi colors
+    #[must_use]
+    pub fn color(self, color: bool) -> Self {
+        Self { color, ..self }
+    }
+}
+
+/// Filter out diagnostics we want to ignore.
+///
+/// Should only be necessary until <https://github.com/astral-sh/ty/issues/2599> is fixed.
+fn filter_diagnostics(d: &Diagnostic) -> bool {
+    !(matches!(d.id(), DiagnosticId::InvalidSyntax)
+        && matches!(
+            d.primary_message(),
+            "`await` statement outside of a function" | "`await` outside of an asynchronous function"
+        ))
+}

package/ref-monty/crates/monty-type-checking/tests/bad_types.py

@@ -0,0 +1,109 @@
+# This file contains intentional type errors to test the type checker.
+# Each section demonstrates a different category of type error.
+# ===
+
+import sys
+from typing import assert_type
+
+
+def takes_int(x: int) -> None:
+    pass
+
+
+def takes_str(x: str) -> None:
+    pass
+
+
+def takes_list_int(x: list[int]) -> None:
+    pass
+
+
+# Wrong primitive types
+takes_int('hello')
+takes_int(3.14)
+takes_str(42)
+takes_str([1, 2, 3])
+
+# Wrong container element types
+takes_list_int(['a', 'b', 'c'])
+takes_list_int([1.0, 2.0, 3.0])
+
+
+# === Invalid return types ===
+
+
+def should_return_int() -> int:
+    return 'oops'
+
+
+def should_return_str() -> str:
+    return 123
+
+
+def should_return_list_int() -> list[int]:
+    return ['a', 'b']
+
+
+def should_return_none() -> None:
+    return 42
+
+
+# === Type mismatches in expressions ===
+
+
+def get_int() -> int:
+    return 42
+
+
+def get_str() -> str:
+    return 'hello'
+
+
+# Binary operations with incompatible types
+result1 = get_int() + get_str()
+result2 = get_str() - get_int()
+
+
+# === assert_type failures ===
+
+x: int = 42
+assert_type(x, str)
+
+y: list[int] = [1, 2, 3]
+assert_type(y, list[str])
+
+
+# === Attribute errors ===
+
+
+class MyClass:
+    def __init__(self) -> None:
+        self.value: int = 42
+
+
+obj = MyClass()
+z = obj.nonexistent_attr
+
+
+# === Too many / too few arguments ===
+
+
+def takes_two(a: int, b: str) -> None:
+    pass
+
+
+takes_two(1)
+takes_two(1, 'hello', 'extra')
+
+
+# === Wrong keyword arguments ===
+
+takes_two(a=1, c='wrong')
+
+
+# === Calling non-callable ===
+
+not_callable: int = 42
+not_callable()
+
+print(sys.copyright)

package/ref-monty/crates/monty-type-checking/tests/bad_types_output.txt

@@ -0,0 +1,21 @@
+bad_types.py:22:11: error[invalid-argument-type] Argument to function `takes_int` is incorrect: Expected `int`, found `Literal["hello"]`
+bad_types.py:23:11: error[invalid-argument-type] Argument to function `takes_int` is incorrect: Expected `int`, found `float`
+bad_types.py:24:11: error[invalid-argument-type] Argument to function `takes_str` is incorrect: Expected `str`, found `Literal[42]`
+bad_types.py:25:11: error[invalid-argument-type] Argument to function `takes_str` is incorrect: Expected `str`, found `list[Unknown | int]`
+bad_types.py:28:16: error[invalid-argument-type] Argument to function `takes_list_int` is incorrect: Expected `list[int]`, found `list[int | str]`
+bad_types.py:29:16: error[invalid-argument-type] Argument to function `takes_list_int` is incorrect: Expected `list[int]`, found `list[int | float]`
+bad_types.py:36:12: error[invalid-return-type] Return type does not match returned value: expected `int`, found `Literal["oops"]`
+bad_types.py:40:12: error[invalid-return-type] Return type does not match returned value: expected `str`, found `Literal[123]`
+bad_types.py:44:12: error[invalid-return-type] Return type does not match returned value: expected `list[int]`, found `list[int | str]`
+bad_types.py:48:12: error[invalid-return-type] Return type does not match returned value: expected `None`, found `Literal[42]`
+bad_types.py:63:11: error[unsupported-operator] Operator `+` is not supported between objects of type `int` and `str`
+bad_types.py:64:11: error[unsupported-operator] Operator `-` is not supported between objects of type `str` and `int`
+bad_types.py:70:1: error[type-assertion-failure] Type `str` does not match asserted type `Literal[42]`
+bad_types.py:73:1: error[type-assertion-failure] Type `list[str]` does not match asserted type `list[int]`
+bad_types.py:85:5: error[unresolved-attribute] Object of type `MyClass` has no attribute `nonexistent_attr`
+bad_types.py:95:1: error[missing-argument] No argument provided for required parameter `b` of function `takes_two`
+bad_types.py:96:23: error[too-many-positional-arguments] Too many positional arguments to function `takes_two`: expected 2, got 3
+bad_types.py:101:1: error[missing-argument] No argument provided for required parameter `b` of function `takes_two`
+bad_types.py:101:16: error[unknown-argument] Argument `c` does not match any known parameter of function `takes_two`
+bad_types.py:107:1: error[call-non-callable] Object of type `Literal[42]` is not callable
+bad_types.py:109:7: error[unresolved-attribute] Module `sys` has no member `copyright`