Merge branch 'main' into add-has-preserved-definition-tests-434298203320126471

Signed-off-by: Adam Poulemanos <89049923+bashandbone@users.noreply.github.com>

Author: bashandbone

ruff.toml

@@ -32,6 +32,7 @@ exclude = [
   "venv",
   "typings",
   "tests/fixtures/malformed.py",
+  "tests/fixtures/sample_type_aliases.py",
 ]
 extend-include = ["*.ipynb"]
 fix = true
@@ -157,6 +158,9 @@ exclude = [
 convention = "google"
 
 [lint.per-file-ignores]
+"tests/fixtures/sample_type_aliases.py" = [
+  "UP040", # Intentionally using TypeAlias for backwards compatibility testing
+]
 "tests/*.py" = [
   "ANN",
   "C901",  # too complex
@@ -204,3 +208,6 @@ force-wrap-aliases = false
 lines-after-imports = 2
 lines-between-types = 1
 split-on-trailing-comma = false
+
+[lint.extend-per-file-ignores]
+"tests/fixtures/sample_type_aliases.py" = ["UP040"]

run_sed.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+sed -i 's/issues = validator.validate_file(test_file)/issues, _, _ = validator.validate_file(test_file)/g' tests/test_validator.py
+sed -i 's/issues = validator.validate_file(test_file)/issues, _, _ = validator.validate_file(test_file)/g' tests/test_integration.py

src/exportify/analysis/ast_parser.py

@@ -40,13 +40,11 @@ class ASTParser:
     def __init__(self):
         """Initialize AST parser."""
 
-    def parse_file(self, file_path: Path, module_path: str) -> AnalysisResult:
+    def parse_file(self, file_path: Path) -> AnalysisResult:
         """Parse a Python file and extract exports.
 
         Args:
             file_path: Path to Python file
-            module_path: Module path (e.g., "codeweaver.core.types")
-
         Returns:
             AnalysisResult with symbols and metadata
         """
@@ -69,8 +67,8 @@ def parse_file(self, file_path: Path, module_path: str) -> AnalysisResult:
             )
 
         # Extract symbols (both defined and imported)
-        defined_symbols = self._extract_symbols(tree, file_path)
-        imported_symbols = self._extract_import_symbols(tree, file_path)
+        defined_symbols = self._extract_symbols(tree)
+        imported_symbols = self._extract_import_symbols(tree)
         all_symbols = defined_symbols + imported_symbols
 
         # Extract imports as strings for backward compatibility/caching
@@ -88,12 +86,11 @@ def parse_file(self, file_path: Path, module_path: str) -> AnalysisResult:
             declared_all=declared_all,
         )
 
-    def _extract_symbols(self, tree: ast.Module, file_path: Path) -> list[DetectedSymbol]:
+    def _extract_symbols(self, tree: ast.Module) -> list[DetectedSymbol]:
         """Extract all exportable symbols from AST.
 
         Args:
             tree: Parsed AST module
-            file_path: Path to source file (for error reporting)
 
         Returns:
             List of detected symbols
@@ -254,7 +251,7 @@ def _determine_variable_type(self, name: str, annotation: ast.expr | None) -> Me
         # Default to variable
         return MemberType.VARIABLE
 
-    def _extract_import_symbols(self, tree: ast.Module, file_path: Path) -> list[DetectedSymbol]:
+    def _extract_import_symbols(self, tree: ast.Module) -> list[DetectedSymbol]:
         """Extract import statements as ParsedSymbol objects.
 
         Categorizes imports with heuristic metadata to help distinguish likely re-exports

src/exportify/export_manager/module_all.py

@@ -118,7 +118,7 @@ def _compute_rule_actions(
     Returns:
         Mapping of symbol name to its :class:`~exportify.common.types.RuleAction`.
     """
-    result = ASTParser().parse_file(file, module_path)
+    result = ASTParser().parse_file(file)
     return {
         symbol.name: rules.evaluate(symbol, module_path).action
         for symbol in result.symbols

src/exportify/pipeline.py

@@ -351,7 +351,7 @@ def _process_file(self, file_path: Path, source_root: Path) -> None:
             self.stats.cache_misses += 1
             self.stats.files_analyzed += 1
 
-            analysis = self.ast_parser.parse_file(file_path, module_path)
+            analysis = self.ast_parser.parse_file(file_path)
 
             # Cache result
             self.cache.put(file_path, file_hash, analysis)

src/exportify/validator/validator.py

@@ -52,19 +52,7 @@ def __init__(
         self.resolver = ImportResolver(project_root=self.project_root)
         self.consistency_checker = ConsistencyChecker(project_root=self.project_root)
 
-    def validate_file(self, file_path: Path) -> list[ValidationError | ValidationWarning]:
-        """Validate a single Python file.
-
-        Args:
-            file_path: Path to Python file to validate
-
-        Returns:
-            List of validation errors and warnings
-        """
-        issues, _, _ = self._validate_file_with_metrics(file_path)
-        return issues
-
-    def _validate_file_with_metrics(
+    def validate_file(
         self, file_path: Path
     ) -> tuple[list[ValidationError | ValidationWarning], int, ast.AST | None]:
         """Validate a single Python file and count lateimport calls.
@@ -151,11 +139,11 @@ def _check_structure_and_imports(
         if not isinstance(tree, ast.Module):
             return has_type_checking_block, has_lateimport_calls
 
-        for i, node in enumerate(tree.body):
+        for node in tree.body:
             is_import = isinstance(node, (ast.Import, ast.ImportFrom))
             is_code = self._is_code_statement(node, is_import=is_import)
 
-            if is_import and seen_code and not self._is_type_checking_block(tree.body[:i]):
+            if is_import and seen_code:
                 issues.append(
                     ValidationWarning(
                         file=file_path,
@@ -252,7 +240,7 @@ def validate_files(self, file_paths: list[Path]) -> list[ValidationError | Valid
         """
         all_issues: list[ValidationError | ValidationWarning] = []
         for file_path in file_paths:
-            issues = self.validate_file(file_path)
+            issues, _, _ = self.validate_file(file_path)
             all_issues.extend(issues)
         return all_issues
 
@@ -286,7 +274,7 @@ def validate(self, file_paths: list[Path] | None = None) -> ValidationReport:
         parsed_trees: dict[Path, ast.AST] = {}
 
         for file_path in file_paths:
-            results, count, tree = self._validate_file_with_metrics(file_path)
+            results, count, tree = self.validate_file(file_path)
 
             # Separate errors and warnings
             errors = [r for r in results if isinstance(r, ValidationError)]
@@ -526,15 +514,12 @@ def _is_type_checking_guard(self, node: ast.If) -> bool:
         """
         return isinstance(node.test, ast.Name) and node.test.id == "TYPE_CHECKING"
 
-    def _is_type_checking_block(self, nodes: list[ast.stmt]) -> bool:
+    def _is_type_checking_block(self) -> bool:
         """Check if we're currently in a TYPE_CHECKING block.
 
         This is a simplified check - it just looks for any TYPE_CHECKING if in the nodes.
         More sophisticated tracking would be needed for nested structures.
 
-        Args:
-            nodes: List of AST nodes to check (body up to current position)
-
         Returns:
             True if there's a TYPE_CHECKING block in the nodes (simplified)
         """

tests/fixtures/sample_type_aliases.py

@@ -13,15 +13,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING
-
-
-if TYPE_CHECKING:
-    # Dummy usage of type aliases to keep static analyzers happy.
-    test_file_path: FilePath | None = None
-
-from typing import TypeAlias
-
+from typing import TYPE_CHECKING, TypeAlias
 
 # Pre-3.12 style type aliases (X: TypeAlias = Y)
 FilePath: TypeAlias = str | Path
@@ -32,9 +24,15 @@
 ConfigDict: TypeAlias = dict[str, str | int | bool | list[str]]
 NamePair: TypeAlias = tuple[str, str]
 
+if TYPE_CHECKING:
+    # Dummy usage of type aliases to keep static analyzers happy.
+    test_file_path: FilePath | None = None
+
 # Python 3.12+ style type aliases (type X = Y)
 type FileContent = str
 type LineNumber = int
+type LineNumber = int
 type ColumnNumber = int
 type SymbolName = str
 type ModulePath = str
+# ruff: noqa: UP040

tests/repro_performance.py

@@ -0,0 +1,42 @@
+import time
+
+from pathlib import Path
+
+from exportify.validator.validator import LateImportValidator
+
+
+def run_benchmark():
+    # Setup dummy files
+    tmp_dir = Path("bench_tmp")
+    tmp_dir.mkdir(exist_ok=True)
+    files = []
+
+    # Create large files
+    content = "from typing import TYPE_CHECKING\n" * 100
+    content += "if TYPE_CHECKING:\n"
+    content += "    import os\n" * 100
+    content += "def foo():\n"
+    content += "    os = lateimport('os', 'os')\n" * 100
+
+    for i in range(100):
+        f = tmp_dir / f"test_file_{i}.py"
+        f.write_text(content)
+        files.append(f)
+
+    validator = LateImportValidator(project_root=tmp_dir)
+
+    start = time.time()
+    for _ in range(50):
+        validator.validate(file_paths=files)
+    end = time.time()
+
+    # Cleanup
+    for f in files:
+        f.unlink()
+    tmp_dir.rmdir()
+
+    print(f"Validation took {end - start:.4f} seconds for 5000 large files")
+
+
+if __name__ == "__main__":
+    run_benchmark()