type-python 0.0.7__tar.gz → 0.1.0__tar.gz

{type_python-0.0.7 → type_python-0.1.0}/Cargo.lock

@@ -1807,6 +1807,7 @@ dependencies = [
  "flate2",
  "glob",
  "notify",
+ "rayon",
  "serde",
  "serde_json",
  "tar",

{type_python-0.0.7 → type_python-0.1.0}/Cargo.toml

@@ -28,6 +28,7 @@ clap = { version = "4.5", features = ["derive", "wrap_help"] }
 flate2 = "1"
 glob = "0.3"
 notify = "6"
+rayon = "1.10"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tar = "0.4"

{type_python-0.0.7 → type_python-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: type-python
-Version: 0.0.7
+Version: 0.1.0
 Summary: A statically-typed authoring language that compiles to standard Python
 Author: unadlib
 License-Expression: MIT

{type_python-0.0.7 → type_python-0.1.0}/README.md

@@ -142,7 +142,7 @@ typepython verify  --project .          # Validate for publication
 typepython migrate --project . --report # Migration coverage report
 ```
 
-Project-oriented commands except `clean` support `--format text|json`. `typepython lsp` always speaks JSON-RPC over stdio rather than CLI JSON output. See [CLI reference](docs/cli-reference.md).
+Project-oriented commands `check`, `build`, `watch`, `verify`, and `migrate` support `--format text|json`. `clean` does not. `typepython lsp` speaks JSON-RPC over stdio rather than CLI JSON output. See [CLI reference](docs/cli-reference.md).
 
 ## Configuration
 
@@ -186,9 +186,10 @@ See [configuration reference](docs/configuration.md).
 ## Contributing
 
 ```bash
-make ci              # format + lint + test + bench-check + package-check
-make test            # run all 846 tests
+make ci              # format + lint + split test suites + bench-check + package-check
+make test            # run the full workspace test suite
 make bench           # run performance benchmarks
+make bump-version VERSION=0.0.8  # sync Rust + Python package versions
 make snapshot-review # review insta snapshot changes
 ```
 

{type_python-0.0.7 → type_python-0.1.0}/crates/typepython_binding/src/types.rs

@@ -60,12 +60,14 @@ pub struct ModuleSurfaceFacts {
     pub dataclass_transform_module_info: typepython_syntax::DataclassTransformModuleInfo,
 }
 
+/// Wrapper around a parsed type expression captured from bound source text.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct BoundTypeExpr {
     pub expr: typepython_syntax::TypeExpr,
 }
 
 impl BoundTypeExpr {
+    /// Parses text into a bound type expression, falling back to a name node when parsing fails.
     #[must_use]
     pub fn new(text: impl Into<String>) -> Self {
         let text = text.into();
@@ -75,23 +77,27 @@ impl BoundTypeExpr {
         }
     }
 
+    /// Wraps an already parsed type expression.
     #[must_use]
     pub fn from_expr(expr: typepython_syntax::TypeExpr) -> Self {
         Self { expr }
     }
 
+    /// Renders the bound expression back to canonical text form.
     #[must_use]
     pub fn render(&self) -> String {
         self.expr.render()
     }
 }
 
+/// Resolved symbol portion of an import target such as `pkg.mod.Name`.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct BoundImportSymbolTarget {
     pub module_key: String,
     pub symbol_name: String,
 }
 
+/// Structured import target extracted from a declaration.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct BoundImportTarget {
     pub raw_target: String,
@@ -100,6 +106,7 @@ pub struct BoundImportTarget {
 }
 
 impl BoundImportTarget {
+    /// Builds a structured import target from the source-authored raw import string.
     #[must_use]
     pub fn new(raw_target: impl Into<String>) -> Self {
         let raw_target = raw_target.into();
@@ -112,6 +119,7 @@ impl BoundImportTarget {
     }
 }
 
+/// Bound callable signature used by later graph and checker phases.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct BoundCallableSignature {
     pub params: Vec<typepython_syntax::DirectFunctionParamSite>,

{type_python-0.0.7 → type_python-0.1.0}/crates/typepython_checking/src/generic_solver.rs

@@ -253,6 +253,111 @@ impl GenericSolverState {
     }
 }
 
+fn infer_variadic_annotation_bindings_detailed(
+    solver: &mut GenericSolverState,
+    node: &typepython_graph::ModuleNode,
+    nodes: &[typepython_graph::ModuleNode],
+    annotation: &SemanticType,
+    positional_types: &[String],
+    positional_index: usize,
+    variadic_starred_types: &[String],
+) -> Result<(), GenericSolveFailure> {
+    if extract_param_spec_args_name_from_semantic(annotation).is_some() {
+        return Ok(());
+    }
+    if let Some(type_pack_name) =
+        type_pack_name_from_unpack_semantic_annotation(annotation, &solver.metadata.type_pack_names)
+    {
+        let fixed_types = positional_types[positional_index..]
+            .iter()
+            .map(|ty| lower_type_text_or_name(ty))
+            .collect::<Vec<_>>();
+        let variadic_tail = if variadic_starred_types.is_empty() {
+            None
+        } else {
+            Some(join_semantic_type_candidates(
+                variadic_starred_types.iter().map(|ty| lower_type_text_or_name(ty)).collect(),
+            ))
+        };
+        solver.record_type_pack_binding(
+            &type_pack_name,
+            TypePackBinding { types: fixed_types, variadic_tail },
+        );
+        return Ok(());
+    }
+
+    let existing = solver.current_bindings_detailed(node, nodes)?;
+    for actual in positional_types.iter().skip(positional_index) {
+        let actual_type = lower_type_text_or_name(actual);
+        let bindings = infer_generic_type_param_bindings(
+            node,
+            nodes,
+            annotation,
+            &actual_type,
+            &solver.metadata.type_names,
+            &existing,
+            &solver.metadata.type_pack_names,
+        )
+        .ok_or_else(|| GenericSolveFailure::TypeBindingInferenceFailed {
+            annotation: annotation.clone(),
+            actual: actual_type,
+        })?;
+        solver.record_bindings(bindings);
+    }
+
+    Ok(())
+}
+
+fn infer_single_argument_bindings_detailed(
+    solver: &mut GenericSolverState,
+    node: &typepython_graph::ModuleNode,
+    nodes: &[typepython_graph::ModuleNode],
+    annotation: &SemanticType,
+    actual_type: SemanticType,
+    actual_value: Option<&typepython_syntax::DirectExprMetadata>,
+) -> Result<(), GenericSolveFailure> {
+    let annotation_mentions_param_spec = annotation.callable_parts().is_some_and(|(params, _)| {
+        callable_param_expr_mentions_param_spec_semantic(params, &solver.metadata.param_spec_names)
+    });
+    let existing = solver.current_bindings_detailed(node, nodes)?;
+    let bindings = infer_callable_param_spec_bindings(
+        node,
+        nodes,
+        annotation,
+        &actual_type,
+        actual_value,
+        &solver.metadata.type_names,
+        &solver.metadata.param_spec_names,
+        &existing,
+    )
+    .ok_or_else(|| GenericSolveFailure::ParamSpecInferenceFailed {
+        annotation: annotation.clone(),
+        actual: actual_type.clone(),
+    })?;
+    solver.record_bindings(bindings);
+    if annotation_mentions_param_spec {
+        return Ok(());
+    }
+
+    let existing = solver.current_bindings_detailed(node, nodes)?;
+    let bindings = infer_generic_type_param_bindings(
+        node,
+        nodes,
+        annotation,
+        &actual_type,
+        &solver.metadata.type_names,
+        &existing,
+        &solver.metadata.type_pack_names,
+    )
+    .ok_or_else(|| GenericSolveFailure::TypeBindingInferenceFailed {
+        annotation: annotation.clone(),
+        actual: actual_type,
+    })?;
+    solver.record_bindings(bindings);
+
+    Ok(())
+}
+
 fn solve_collected_generic_constraints_detailed(
     node: &typepython_graph::ModuleNode,
     nodes: &[typepython_graph::ModuleNode],
@@ -593,104 +698,30 @@ pub(crate) fn infer_generic_type_param_substitutions_detailed(
         };
         let annotation = lower_type_text_or_name(&annotation_text);
         if param.variadic {
-            if extract_param_spec_args_name_from_semantic(&annotation).is_some() {
-                positional_index = positional_types.len();
-                continue;
-            }
-            if let Some(type_pack_name) = type_pack_name_from_unpack_semantic_annotation(
+            infer_variadic_annotation_bindings_detailed(
+                &mut solver,
+                node,
+                nodes,
                 &annotation,
-                &solver.metadata.type_pack_names,
-            ) {
-                let fixed_types = positional_types[positional_index..]
-                    .iter()
-                    .map(|ty| lower_type_text_or_name(ty))
-                    .collect::<Vec<_>>();
-                let variadic_tail = if variadic_starred_types.is_empty() {
-                    None
-                } else {
-                    Some(join_semantic_type_candidates(
-                        variadic_starred_types
-                            .iter()
-                            .map(|ty| lower_type_text_or_name(ty))
-                            .collect(),
-                    ))
-                };
-                solver.record_type_pack_binding(
-                    &type_pack_name,
-                    TypePackBinding { types: fixed_types, variadic_tail },
-                );
-                positional_index = positional_types.len();
-                continue;
-            }
-            let existing = solver.current_bindings_detailed(node, nodes)?;
-            for actual in positional_types.iter().skip(positional_index) {
-                let actual_type = lower_type_text_or_name(actual);
-                let bindings = infer_generic_type_param_bindings(
-                    node,
-                    nodes,
-                    &annotation,
-                    &actual_type,
-                    &solver.metadata.type_names,
-                    &existing,
-                    &solver.metadata.type_pack_names,
-                )
-                .ok_or_else(|| {
-                    GenericSolveFailure::TypeBindingInferenceFailed {
-                        annotation: annotation.clone(),
-                        actual: actual_type,
-                    }
-                })?;
-                solver.record_bindings(bindings);
-            }
+                &positional_types,
+                positional_index,
+                &variadic_starred_types,
+            )?;
             positional_index = positional_types.len();
             continue;
         }
         let Some(actual) = positional_types.get(positional_index) else {
             continue;
         };
-        let annotation_mentions_param_spec =
-            annotation.callable_parts().is_some_and(|(params, _)| {
-                callable_param_expr_mentions_param_spec_semantic(
-                    params,
-                    &solver.metadata.param_spec_names,
-                )
-            });
-        let existing = solver.current_bindings_detailed(node, nodes)?;
         let actual_type = lower_type_text_or_name(actual);
-        let bindings = infer_callable_param_spec_bindings(
+        infer_single_argument_bindings_detailed(
+            &mut solver,
             node,
             nodes,
             &annotation,
-            &actual_type,
+            actual_type,
             call.arg_values.get(positional_index),
-            &solver.metadata.type_names,
-            &solver.metadata.param_spec_names,
-            &existing,
-        )
-        .ok_or_else(|| GenericSolveFailure::ParamSpecInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type.clone(),
-        })?;
-        solver.record_bindings(bindings);
-        if annotation_mentions_param_spec {
-            positional_index += 1;
-            continue;
-        }
-        let existing = solver.current_bindings_detailed(node, nodes)?;
-        let bindings = infer_generic_type_param_bindings(
-            node,
-            nodes,
-            &annotation,
-            &actual_type,
-            &solver.metadata.type_names,
-            &existing,
-            &solver.metadata.type_pack_names,
-        )
-        .ok_or_else(|| GenericSolveFailure::TypeBindingInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type,
-        })?;
-        solver.record_bindings(bindings);
+        )?;
         positional_index += 1;
     }
 
@@ -704,48 +735,15 @@ pub(crate) fn infer_generic_type_param_substitutions_detailed(
             continue;
         };
         let annotation = lower_type_text_or_name(&annotation_text);
-        let annotation_mentions_param_spec =
-            annotation.callable_parts().is_some_and(|(params, _)| {
-                callable_param_expr_mentions_param_spec_semantic(
-                    params,
-                    &solver.metadata.param_spec_names,
-                )
-            });
-        let existing = solver.current_bindings_detailed(node, nodes)?;
         let actual_type = lower_type_text_or_name(actual);
-        let bindings = infer_callable_param_spec_bindings(
+        infer_single_argument_bindings_detailed(
+            &mut solver,
             node,
             nodes,
             &annotation,
-            &actual_type,
+            actual_type,
             call.keyword_arg_values.get(index),
-            &solver.metadata.type_names,
-            &solver.metadata.param_spec_names,
-            &existing,
-        )
-        .ok_or_else(|| GenericSolveFailure::ParamSpecInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type.clone(),
-        })?;
-        solver.record_bindings(bindings);
-        if annotation_mentions_param_spec {
-            continue;
-        }
-        let existing = solver.current_bindings_detailed(node, nodes)?;
-        let bindings = infer_generic_type_param_bindings(
-            node,
-            nodes,
-            &annotation,
-            &actual_type,
-            &solver.metadata.type_names,
-            &existing,
-            &solver.metadata.type_pack_names,
-        )
-        .ok_or_else(|| GenericSolveFailure::TypeBindingInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type,
-        })?;
-        solver.record_bindings(bindings);
+        )?;
     }
 
     solver.finish_detailed(node, nodes)
@@ -775,104 +773,30 @@ pub(crate) fn infer_generic_type_param_substitutions_from_semantic_params_detail
             continue;
         };
         if param.variadic {
-            if extract_param_spec_args_name_from_semantic(&annotation).is_some() {
-                positional_index = positional_types.len();
-                continue;
-            }
-            if let Some(type_pack_name) = type_pack_name_from_unpack_semantic_annotation(
+            infer_variadic_annotation_bindings_detailed(
+                &mut solver,
+                node,
+                nodes,
                 &annotation,
-                &solver.metadata.type_pack_names,
-            ) {
-                let fixed_types = positional_types[positional_index..]
-                    .iter()
-                    .map(|ty| lower_type_text_or_name(ty))
-                    .collect::<Vec<_>>();
-                let variadic_tail = if variadic_starred_types.is_empty() {
-                    None
-                } else {
-                    Some(join_semantic_type_candidates(
-                        variadic_starred_types
-                            .iter()
-                            .map(|ty| lower_type_text_or_name(ty))
-                            .collect(),
-                    ))
-                };
-                solver.record_type_pack_binding(
-                    &type_pack_name,
-                    TypePackBinding { types: fixed_types, variadic_tail },
-                );
-                positional_index = positional_types.len();
-                continue;
-            }
-            let existing = solver.current_bindings_detailed(node, nodes)?;
-            for actual in positional_types.iter().skip(positional_index) {
-                let actual_type = lower_type_text_or_name(actual);
-                let bindings = infer_generic_type_param_bindings(
-                    node,
-                    nodes,
-                    &annotation,
-                    &actual_type,
-                    &solver.metadata.type_names,
-                    &existing,
-                    &solver.metadata.type_pack_names,
-                )
-                .ok_or_else(|| {
-                    GenericSolveFailure::TypeBindingInferenceFailed {
-                        annotation: annotation.clone(),
-                        actual: actual_type,
-                    }
-                })?;
-                solver.record_bindings(bindings);
-            }
+                &positional_types,
+                positional_index,
+                &variadic_starred_types,
+            )?;
             positional_index = positional_types.len();
             continue;
         }
         let Some(actual) = positional_types.get(positional_index) else {
             continue;
         };
-        let annotation_mentions_param_spec =
-            annotation.callable_parts().is_some_and(|(params, _)| {
-                callable_param_expr_mentions_param_spec_semantic(
-                    params,
-                    &solver.metadata.param_spec_names,
-                )
-            });
-        let existing = solver.current_bindings_detailed(node, nodes)?;
         let actual_type = lower_type_text_or_name(actual);
-        let bindings = infer_callable_param_spec_bindings(
+        infer_single_argument_bindings_detailed(
+            &mut solver,
             node,
             nodes,
             &annotation,
-            &actual_type,
+            actual_type,
             call.arg_values.get(positional_index),
-            &solver.metadata.type_names,
-            &solver.metadata.param_spec_names,
-            &existing,
-        )
-        .ok_or_else(|| GenericSolveFailure::ParamSpecInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type.clone(),
-        })?;
-        solver.record_bindings(bindings);
-        if annotation_mentions_param_spec {
-            positional_index += 1;
-            continue;
-        }
-        let existing = solver.current_bindings_detailed(node, nodes)?;
-        let bindings = infer_generic_type_param_bindings(
-            node,
-            nodes,
-            &annotation,
-            &actual_type,
-            &solver.metadata.type_names,
-            &existing,
-            &solver.metadata.type_pack_names,
-        )
-        .ok_or_else(|| GenericSolveFailure::TypeBindingInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type,
-        })?;
-        solver.record_bindings(bindings);
+        )?;
         positional_index += 1;
     }
 
@@ -885,48 +809,15 @@ pub(crate) fn infer_generic_type_param_substitutions_from_semantic_params_detail
         let Some(annotation) = param.annotation.clone() else {
             continue;
         };
-        let annotation_mentions_param_spec =
-            annotation.callable_parts().is_some_and(|(params, _)| {
-                callable_param_expr_mentions_param_spec_semantic(
-                    params,
-                    &solver.metadata.param_spec_names,
-                )
-            });
-        let existing = solver.current_bindings_detailed(node, nodes)?;
         let actual_type = lower_type_text_or_name(actual);
-        let bindings = infer_callable_param_spec_bindings(
+        infer_single_argument_bindings_detailed(
+            &mut solver,
             node,
             nodes,
             &annotation,
-            &actual_type,
+            actual_type,
             call.keyword_arg_values.get(index),
-            &solver.metadata.type_names,
-            &solver.metadata.param_spec_names,
-            &existing,
-        )
-        .ok_or_else(|| GenericSolveFailure::ParamSpecInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type.clone(),
-        })?;
-        solver.record_bindings(bindings);
-        if annotation_mentions_param_spec {
-            continue;
-        }
-        let existing = solver.current_bindings_detailed(node, nodes)?;
-        let bindings = infer_generic_type_param_bindings(
-            node,
-            nodes,
-            &annotation,
-            &actual_type,
-            &solver.metadata.type_names,
-            &existing,
-            &solver.metadata.type_pack_names,
-        )
-        .ok_or_else(|| GenericSolveFailure::TypeBindingInferenceFailed {
-            annotation: annotation.clone(),
-            actual: actual_type,
-        })?;
-        solver.record_bindings(bindings);
+        )?;
     }
 
     solver.finish_detailed(node, nodes)

{type_python-0.0.7 → type_python-0.1.0}/crates/typepython_checking/src/lib.rs

@@ -103,6 +103,7 @@ pub struct ModuleCheckResult {
 }
 
 impl ModuleCheckResult {
+    /// Flattens per-module diagnostics into a single report in module iteration order.
     #[must_use]
     pub fn diagnostics(&self) -> DiagnosticReport {
         let mut diagnostics = DiagnosticReport::default();
@@ -113,6 +114,7 @@ impl ModuleCheckResult {
     }
 }
 
+/// Stub override derived from checker-resolved callable information.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct EffectiveCallableStubOverride {
     pub module_key: String,
@@ -123,6 +125,7 @@ pub struct EffectiveCallableStubOverride {
     pub returns: String,
 }
 
+/// Synthetic method emitted into authoritative stubs for checker-synthesized behavior.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct SyntheticMethodStub {
     pub module_key: String,
@@ -472,6 +475,7 @@ pub fn check(graph: &ModuleGraph) -> CheckResult {
     )
 }
 
+/// Runs the checker with the caller-controlled option surface used by the CLI and tests.
 #[must_use]
 pub fn check_with_options(
     graph: &ModuleGraph,
@@ -499,6 +503,7 @@ pub fn check_with_options(
     clippy::too_many_arguments,
     reason = "mirrors the public checker option surface while threading binding metadata"
 )]
+/// Runs the checker with precomputed binding metadata to avoid recomputing source-derived facts.
 pub fn check_with_binding_metadata(
     graph: &ModuleGraph,
     bindings: &[BindingTable],