superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,475 @@
+import asyncio
+import os
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, assert_type
+
+# === Type checking helper functions ===
+
+
+def check_int(x: int) -> None:
+    pass
+
+
+def check_float(x: float) -> None:
+    pass
+
+
+def check_str(x: str) -> None:
+    pass
+
+
+def check_bool(x: bool) -> None:
+    pass
+
+
+def check_bytes(x: bytes) -> None:
+    pass
+
+
+def check_list_int(x: list[int]) -> None:
+    pass
+
+
+def check_list_str(x: list[str]) -> None:
+    pass
+
+
+def check_tuple_int(x: tuple[int, ...]) -> None:
+    pass
+
+
+def check_dict_str_int(x: dict[str, int]) -> None:
+    pass
+
+
+def check_set_int(x: set[int]) -> None:
+    pass
+
+
+def check_frozenset_int(x: frozenset[int]) -> None:
+    pass
+
+
+# === Value getter functions ===
+
+
+def get_int() -> int:
+    return 123
+
+
+def get_float() -> float:
+    return 3.14
+
+
+def get_str() -> str:
+    return 'hello'
+
+
+def get_list_int() -> list[int]:
+    return [1, 2, 3]
+
+
+def get_list_str() -> list[str]:
+    return ['a', 'b', 'c']
+
+
+def get_object() -> object:
+    return object()
+
+
+def get_dict_str_int() -> dict[str, int]:
+    return {'a': 1, 'b': 2}
+
+
+def get_set_str() -> set[str]:
+    return {'a', 'b', 'c'}
+
+
+def get_frozenset_str() -> frozenset[str]:
+    return frozenset({'a', 'b', 'c'})
+
+
+def get_tuple_str_int() -> tuple[str, int]:
+    return ('hello', 42)
+
+
+def get_bytes() -> bytes:
+    return b'hello'
+
+
+# === Core Types ===
+
+obj = object()
+t = type(42)
+
+
+# === Primitive Types ===
+
+# bool
+check_bool(True)
+check_bool(False)
+check_bool(bool(1))
+check_bool(bool(''))
+
+# int
+check_int(42)
+check_int(int('42'))
+check_int(int(3.14))
+check_int(int(get_int()))
+check_int(int(get_float()))
+
+# float
+check_float(3.14)
+check_float(float('3.14'))
+check_float(float(42))
+f = get_float()
+assert_type(f, float)
+
+
+# === String and Bytes Types ===
+
+# str
+check_str('hello')
+check_str(str(42))
+check_str(str(b'hello', 'utf-8'))
+check_str(str(get_int()))
+
+# bytes
+check_bytes(b'hello')
+check_bytes(bytes('hello', 'utf-8'))
+check_bytes(bytes(10))
+check_bytes(bytes([65, 66, 67]))
+check_bytes(bytes(get_int()))
+k2 = get_bytes()
+assert_type(k2, bytes)
+
+
+# === Container Types ===
+
+# list
+check_list_int([1, 2, 3])
+check_list_str(list('abc'))
+check_list_int(list(range(10)))
+m2 = get_list_int()
+assert_type(m2, list[int])
+m3 = get_list_str()
+assert_type(m3, list[str])
+
+# tuple
+check_tuple_int(tuple([1, 2, 3]))
+p2 = get_tuple_str_int()
+assert_type(p2, tuple[str, int])
+
+# dict
+check_dict_str_int({'a': 1, 'b': 2})
+check_dict_str_int(dict(a=1, b=2))
+d = get_dict_str_int()
+assert_type(d, dict[str, int])
+
+# set
+check_set_int({1, 2, 3})
+check_set_int(set([1, 2, 3]))
+
+# frozenset
+check_frozenset_int(frozenset([1, 2, 3]))
+
+# range
+w = range(get_int())
+assert_type(w, range)
+
+# slice
+sl1 = slice(10)
+sl2 = slice(0, 10)
+sl3 = slice(0, 10, 2)
+
+
+# === Builtin Functions ===
+
+# abs
+check_int(abs(-5))
+check_float(abs(-3.14))
+
+# all / any
+check_bool(all([True, False]))
+check_bool(any([True, False]))
+aa = all(get_list_int())
+assert_type(aa, bool)
+
+# bin / hex / oct
+check_str(bin(42))
+check_str(hex(255))
+check_str(oct(8))
+ac = bin(get_int())
+assert_type(ac, str)
+
+# chr / ord
+check_str(chr(65))
+check_int(ord('A'))
+af = chr(get_int())
+assert_type(af, str)
+ag = ord(get_str())
+assert_type(ag, int)
+
+# divmod
+dm = divmod(10, 3)
+
+# hash
+check_int(hash('hello'))
+ai = hash(get_str())
+assert_type(ai, int)
+
+# id
+check_int(id(object()))
+ak = id(get_object())
+assert_type(ak, int)
+
+# isinstance
+check_bool(isinstance(42, int))
+al = isinstance(get_object(), int)
+assert_type(al, bool)
+
+# len
+check_int(len([1, 2, 3]))
+an = len(get_list_int())
+assert_type(an, int)
+
+# max / min
+check_int(max(1, 2, 3))
+check_int(min(1, 2, 3))
+
+# pow
+check_int(pow(2, 3))
+check_float(pow(2.0, 3.0))
+
+# print
+aw = print(get_str())
+assert_type(aw, None)
+
+# repr
+check_str(repr(42))
+ax = repr(get_int())
+assert_type(ax, str)
+
+# round
+check_int(round(3.7))
+
+# sorted
+check_list_int(sorted([3, 1, 2]))
+
+# sum
+check_int(sum([1, 2, 3]))
+ba = sum(get_list_int())
+assert_type(ba, int)
+
+# type
+bf = type(get_int())
+assert_type(bf, type[int])
+
+
+# === Iterator Types ===
+
+# enumerate
+for i_enum, v_enum in enumerate([1, 2, 3]):
+    check_int(i_enum)
+    check_int(v_enum)
+
+# reversed
+for v_rev in reversed([1, 2, 3]):
+    check_int(v_rev)
+
+# zip
+for a_zip, b_zip in zip([1, 2], ['a', 'b']):
+    check_int(a_zip)
+    check_str(b_zip)
+
+
+# === Literal Types ===
+
+bk = None
+assert_type(bk, None)
+
+
+# === Exception Types ===
+
+e1 = BaseException('error')
+e2 = Exception('error')
+e3 = SystemExit(1)
+e4 = KeyboardInterrupt()
+e5 = ArithmeticError('error')
+e6 = OverflowError('error')
+e7 = ZeroDivisionError('error')
+e8 = LookupError('error')
+e9 = IndexError('error')
+e10 = KeyError('key')
+e11 = RuntimeError('error')
+e12 = NotImplementedError('error')
+e13 = RecursionError('error')
+e14 = AttributeError('error')
+e15 = AssertionError('error')
+e16 = MemoryError('error')
+e17 = NameError('error')
+e18 = SyntaxError('error')
+e19 = TimeoutError('error')
+e20 = TypeError('error')
+e21 = ValueError('error')
+e22 = StopIteration()
+
+
+# === Exception Inheritance ===
+
+
+def handle_base(e: BaseException) -> None:
+    pass
+
+
+handle_base(Exception('error'))
+handle_base(ValueError('error'))
+handle_base(KeyError('key'))
+handle_base(ZeroDivisionError('error'))
+
+
+def handle_exception(e: Exception) -> None:
+    pass
+
+
+handle_exception(ValueError('error'))
+handle_exception(TypeError('error'))
+handle_exception(RuntimeError('error'))
+
+
+# === Try/Except ===
+
+try:
+    x_try = 1 / 0
+except ZeroDivisionError as e_try:
+    check_str(str(e_try))
+
+try:
+    d_try: dict[str, int] = {}
+    v_try = d_try['missing']
+except KeyError:
+    pass
+
+try:
+    lst_try: list[int] = []
+    v_lst = lst_try[0]
+except IndexError:
+    pass
+
+
+# === Raise ===
+
+
+def may_fail(x_fail: int) -> int:
+    if x_fail < 0:
+        raise ValueError('x must be non-negative')
+    if x_fail == 0:
+        raise ZeroDivisionError('x cannot be zero')
+    return 100 // x_fail
+
+
+def not_implemented() -> None:
+    raise NotImplementedError('subclass must implement')
+
+
+print(sys.version)
+print(sys.version_info)
+print(None, file=sys.stdout)
+print(None, file=sys.stderr)
+
+# === async ===
+
+
+async def foo(a: int):
+    return a * 2
+
+
+async def bar():
+    await foo(1)
+    await foo(2)
+    await foo(3)
+
+
+await asyncio.gather(bar())  # pyright: ignore
+
+asyncio.run(foo(1))
+
+
+@dataclass
+class Point:
+    x: int
+    y: float
+
+
+p = Point(1, 2)
+assert_type(p.x, int)
+assert_type(p.y, float)
+p.x = 3
+print(p)
+
+path = Path(__file__)
+assert_type(path, Path)
+# assert_type(path.name, str)
+
+p2 = path.parent
+assert_type(p2, Path)
+
+p3 = path / 'test.txt'
+assert_type(p3, Path)
+assert p3.name == 'test.txt'
+
+x = os.getenv('foobar')
+assert_type(x, str | None)
+
+y = os.getenv('foobar', default=int('123'))
+assert_type(y, str | int)
+
+x2 = os.environ.get('foobar')
+assert_type(x2, str | None)
+
+
+# === re module ===
+
+# re.search returns Match or None
+s1 = re.search(r'\d+', 'abc 42')
+assert_type(s1, re.Match[str] | None)
+
+# re.match returns Match or None
+s2 = re.match(r'\w+', 'hello')
+assert_type(s2, re.Match[str] | None)
+
+# re.fullmatch returns Match or None
+s3 = re.fullmatch(r'\w+', 'hello')
+assert_type(s3, re.Match[str] | None)
+
+# re.compile returns Pattern
+p_re = re.compile(r'\d+')
+assert_type(p_re, re.Pattern[str])
+
+# re.findall returns list of Any
+fa = re.findall(r'\d+', 'a1 b2 c3')
+assert_type(fa, list[Any])
+
+# re.sub returns str
+s4 = re.sub(r'\d+', 'X', 'a1 b2')
+assert_type(s4, str)
+
+# Pattern.search returns Match or None
+p_re2 = re.compile(r'(\w+)')
+s5 = p_re2.search('hello world')
+assert_type(s5, re.Match[str] | None)
+
+# Pattern.match returns Match or None
+s6 = p_re2.match('hello world')
+assert_type(s6, re.Match[str] | None)
+
+# Pattern.sub returns str
+s7 = p_re2.sub('X', 'hello world')
+assert_type(s7, str)
+
+# Pattern.findall returns list of Any
+fa2 = p_re2.findall('hello world')
+assert_type(fa2, list[Any])

package/ref-monty/crates/monty-type-checking/tests/main.rs

@@ -0,0 +1,205 @@
+use std::fs;
+
+use monty_type_checking::{SourceFile, type_check};
+use pretty_assertions::assert_eq;
+use ruff_db::diagnostic::DiagnosticFormat;
+
+#[test]
+fn type_checking_success() {
+    let code = r"
+def add(x: int, y: int) -> int:
+    return x + y
+
+result = add(1, 2)
+    ";
+
+    let result = type_check(&SourceFile::new(code, "main.py"), None).unwrap();
+    assert!(result.is_none());
+}
+
+#[test]
+fn type_checking_error() {
+    let code = "\
+def add(x: int, y: int) -> int:
+    return x + y
+
+result = add(1, '2')
+    ";
+
+    let result = type_check(&SourceFile::new(code, "main.py"), None).unwrap();
+    assert!(result.is_some());
+
+    let error_diagnostics = result.unwrap().to_string();
+    assert_eq!(
+        error_diagnostics,
+        r#"error[invalid-argument-type]: Argument to function `add` is incorrect
+ --> main.py:4:17
+  |
+2 |     return x + y
+3 |
+4 | result = add(1, '2')
+  |                 ^^^ Expected `int`, found `Literal["2"]`
+  |
+info: Function defined here
+ --> main.py:1:5
+  |
+1 | def add(x: int, y: int) -> int:
+  |     ^^^         ------ Parameter declared here
+2 |     return x + y
+  |
+info: rule `invalid-argument-type` is enabled by default
+
+"#
+    );
+}
+
+#[test]
+fn type_checking_error_stubs() {
+    let stubs = "\
+from dataclasses import dataclass
+
+@dataclass
+class User:
+    name: str
+    age: int
+";
+    let code = "\
+def add(x: int, y: int) -> int:
+    return x + y
+
+result = add(1, '2')";
+
+    let result = type_check(
+        &SourceFile::new(code, "main.py"),
+        Some(&SourceFile::new(stubs, "type_stubs.pyi")),
+    )
+    .unwrap();
+
+    let error_diagnostics = result.unwrap();
+    assert_eq!(
+        error_diagnostics.to_string(),
+        r#"error[invalid-argument-type]: Argument to function `add` is incorrect
+ --> main.py:4:17
+  |
+2 |     return x + y
+3 |
+4 | result = add(1, '2')
+  |                 ^^^ Expected `int`, found `Literal["2"]`
+  |
+info: Function defined here
+ --> main.py:1:5
+  |
+1 | def add(x: int, y: int) -> int:
+  |     ^^^         ------ Parameter declared here
+2 |     return x + y
+  |
+info: rule `invalid-argument-type` is enabled by default
+
+"#
+    );
+}
+
+#[test]
+fn type_checking_error_concise() {
+    let code = r"
+def add(x: int, y: int) -> int:
+    return x + y
+
+result = add(1, '2')
+    ";
+
+    let result = type_check(&SourceFile::new(code, "main.py"), None).unwrap();
+    assert!(result.is_some());
+
+    let failure = result.unwrap().format(DiagnosticFormat::Concise);
+    let error_diagnostics = failure.to_string();
+    assert_eq!(
+        error_diagnostics,
+        "main.py:5:17: error[invalid-argument-type] Argument to function `add` is incorrect: Expected `int`, found `Literal[\"2\"]`\n"
+    );
+    let color_failure = failure.color(true).to_string();
+    assert!(color_failure.starts_with('\u{1b}'));
+}
+
+#[test]
+fn missing_stdlib_datetime() {
+    let code = "import datetime\nprint(datetime.datetime.now())";
+
+    let result = type_check(&SourceFile::new(code, "main.py"), None).unwrap();
+    assert!(result.is_some());
+
+    let failure = result.unwrap().format(DiagnosticFormat::Concise);
+    let error_diagnostics = failure.to_string();
+    assert_eq!(
+        error_diagnostics,
+        "main.py:1:8: error[unresolved-import] Cannot resolve imported module `datetime`\n"
+    );
+    let dbg = format!("{failure:?}");
+    assert!(dbg.starts_with("TypeCheckingDiagnostics:"), "got: {dbg}");
+}
+
+/// Test that good_types.py type-checks without errors.
+///
+/// This file uses `assert_type` from typing to verify that inferred types match expected types.
+#[test]
+fn type_good_types() {
+    let code = include_str!("good_types.py");
+    let result = type_check(&SourceFile::new(code, "good_types.py"), None).unwrap();
+    assert!(result.is_none(), "Expected no type errors, got: {result:#?}");
+}
+
+fn check_file_content(file_name: &str, mut actual: &str) {
+    let expected_path = format!("{}/tests/{}", env!("CARGO_MANIFEST_DIR"), file_name);
+    let expected = if fs::exists(&expected_path).unwrap() {
+        fs::read_to_string(&expected_path).unwrap()
+    } else {
+        std::fs::write(&expected_path, actual).unwrap();
+        panic!("{file_name} did not exist, file created.")
+    };
+
+    let expected = expected.as_str().trim();
+    actual = actual.trim();
+
+    if actual == expected {
+        println!("File content matches expected.");
+        return;
+    }
+
+    let status = if std::env::var("UPDATE_EXPECT").is_ok() {
+        std::fs::write(&expected_path, actual).unwrap();
+        "FILE UPDATE"
+    } else {
+        "file not updated, run with UPDATE_EXPECT=1 to update"
+    };
+
+    panic!("Type errors don't match expected.\n\nEXPECTED:\n{expected}\n\nACTUAL:\n{actual}\n\n{status}.");
+}
+
+/// Test that bad_types.py produces the expected type errors.
+///
+/// Set `UPDATE_EXPECT=1` to update the expected errors file.
+#[test]
+fn type_bad_types() {
+    let code = include_str!("bad_types.py");
+    let result = type_check(&SourceFile::new(code, "bad_types.py"), None).unwrap();
+
+    let failure = result.expect("Expected type errors in bad_types.py");
+    let actual = failure
+        .format(ruff_db::diagnostic::DiagnosticFormat::Concise)
+        .to_string();
+
+    check_file_content("bad_types_output.txt", &actual);
+}
+
+#[test]
+fn test_reveal_types() {
+    let code = include_str!("reveal_types.py");
+    let result = type_check(&SourceFile::new(code, "reveal_types.py"), None).unwrap();
+
+    let failure = result.expect("Expected type errors in reveal_types.py");
+    let actual = failure
+        .format(ruff_db::diagnostic::DiagnosticFormat::Concise)
+        .to_string();
+
+    check_file_content("reveal_types_output.txt", &actual);
+}

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

@@ -0,0 +1,56 @@
+from typing import reveal_type
+
+# === Core types ===
+reveal_type(None)
+reveal_type(object())
+reveal_type(type(1))
+
+# === Primitive types ===
+reveal_type(True)
+reveal_type(int(1))
+reveal_type(float(1.2))
+
+# === String/bytes types ===
+reveal_type('hello')
+reveal_type(b'foobar')
+
+# === Container types ===
+reveal_type([1])
+reveal_type((1, 2))
+reveal_type({1: 2})
+reveal_type({1, 2})
+reveal_type(frozenset({1, 2}))
+reveal_type(range(10))
+
+# === Iterator types ===
+reveal_type(enumerate([1, 2]))
+reveal_type(reversed([1, 2]))
+reveal_type(zip([1], [2]))
+
+# === Slicing ===
+reveal_type(slice(1, 2))
+
+# === Exception types ===
+reveal_type(BaseException())
+reveal_type(Exception())
+reveal_type(SystemExit())
+reveal_type(KeyboardInterrupt())
+reveal_type(ArithmeticError())
+reveal_type(OverflowError())
+reveal_type(ZeroDivisionError())
+reveal_type(LookupError())
+reveal_type(IndexError())
+reveal_type(KeyError())
+reveal_type(RuntimeError())
+reveal_type(NotImplementedError())
+reveal_type(RecursionError())
+reveal_type(AttributeError())
+reveal_type(AssertionError())
+reveal_type(MemoryError())
+reveal_type(NameError())
+reveal_type(SyntaxError())
+reveal_type(OSError())
+reveal_type(TimeoutError())
+reveal_type(TypeError())
+reveal_type(ValueError())
+reveal_type(StopIteration())