2 commits

Author	SHA1	Message	Date
Gergő Magyar	5fa73bafdf	feat: Phase 4 type resolution — nullable unwrapping, for-loop typing, assignment chains, code review fixes (#310) ... * feat: Phase 4 type resolution — nullable unwrapping, for-loop typing, assignment chains, Kotlin return types Phase 4.1: Nullable/optional chain unwrapping - Add stripNullable utility in shared.ts for stripping nullable wrappers - Apply in lookupInEnv to unwrap User | null → User, User? → User before receiver lookup - Handles TS union, Kotlin/C#/Swift nullable suffix, Python Union[T, None], Rust Option<T> - Enables receiver-type disambiguation through ?. optional chaining Phase 4.2: For-loop element typing (Tier 0 — Java/C#/Kotlin) - Add ForLoopExtractor type and forLoopNodeTypes to LanguageTypeConfig - Java enhanced_for_statement, C# foreach_statement, Kotlin for_statement extractors - Only explicit element types in AST (Tier 0); inference-based languages deferred Phase 4.3: Assignment chain propagation (single-pass, depth-1) - Add PendingAssignmentExtractor to LanguageTypeConfig with per-language implementations - Handles TS/JS variable_declarator, Rust let_declaration, Python assignment, Go short_var_declaration, C# equals_value_clause, Java/Kotlin variable_declarator - Single post-walk propagation pass (no fixpoint iteration per Sorbet/Pyright design) - Resolves const b = a; b.save() when a has known type from Tier 0/1/1b Phase 4.5: Kotlin return type extraction (bug fix) - Fix extractMethodSignature to handle Kotlin user_type after function_value_parameters - Remove lenient test assertions, add strict disambiguation proof Integration tests across 10+ languages with competing same-name methods and negative assertions proving disambiguation. * fix: per-language assignment chain gaps from code review - Kotlin: new extractKotlinPendingAssignment for property_declaration → variable_declaration AST (Java's variable_declarator doesn't exist in Kotlin) - Go: handle var_spec (var b = u) alongside short_var_declaration (:=) - PHP: add extractPendingAssignment for $alias = $user with $ prefix preserved Integration tests added for all three languages with competing same-name methods and negative disambiguation assertions. * fix: code review fixes — DRY nullable keywords, avoid array allocations, clarify depth comment Addresses findings from 6-agent code review on PR #310: - Move stripNullable JSDoc to correct position (was orphaned above NULLABLE_KEYWORDS) - DRY: reuse NULLABLE_KEYWORDS set in pipe-split filter instead of inline strings - Replace node.children.find() with findChildByType/manual loops in jvm.ts, go.ts, csharp.ts to avoid unnecessary array allocations per tree-sitter call - Clarify "depth-1" comment in type-env.ts: single-pass resolves multi-hop chains when forward-declared; reverse-order is depth-1 only - Annotate extractGenericTypeArgs as Phase 5 infrastructure (zero production callers) - Re-export PendingAssignmentExtractor from index.ts for API consistency - Add explicit return undefined in Go extractPendingAssignment - Remove redundant child.text === '=' check in Kotlin extractor Test coverage: - 20 new unit tests: stripNullable edge cases, per-language assignment chains, reverse-order depth limitation, nullable lookup resolution - 15 new integration tests: multi-hop chains (a→b→c), nullable+chain combined (User|null + alias), Python User|None through stripNullable path - 3 new fixtures: ts-multi-hop-chain, ts-nullable-chain, python-nullable-chain * fix: third-pass review — walrus chain, scanner allocations, Kotlin variable_declaration, C# type guard Addresses 4 new findings from third-pass CI review: 1. Python walrus operator (:=) now handled by extractPendingAssignment — named_expression nodes propagate alias chains alongside regular assignment 2. Scanner .namedChildren.find()/.some() in jvm.ts replaced with findChildByType() — consistent with 98daed4 code review fixes 3. Kotlin extractPendingAssignment extended to handle variable_declaration nodes in addition to property_declaration (function-local val/var) 4. C# extractPendingAssignment early-returns for is_pattern_expression and field_declaration nodes (never contain variable_declarator children) Integration tests: - Python: walrus chain (alias := u) with disambiguation (5 tests, 1 fixture) - Kotlin: assignment chain with typed declarations (5 tests, 1 fixture) - C#: assignment chain + is-pattern coexistence (6 tests, 1 fixture) - Unit: Python walrus propagation (1 test) * feat: nullable wrapper unwrapping + C++ assignment chains Gaps 1, 2, 4 from code review — architectural changes to type resolution: 1. extractSimpleTypeName now unwraps nullable wrapper generics: - Optional<User> → "User" (Java), Option<User> → "User" (Rust), Maybe<User> → "User" (Kotlin Arrow/Haskell-style) - Containers (List, Map) and async wrappers (Promise, Future) are NOT unwrapped — methods are called on the container, not the inner type - Uses existing extractGenericTypeArgs (now production-active, was dead code) - NULLABLE_WRAPPER_TYPES set: Optional, Option, Maybe 2. C++ extractPendingAssignment added for auto alias chains: - auto alias = user; alias.save() now propagates User type - Handles pointer/reference declarators, auto/decltype(auto) 3. Updated existing Rust test: Option<User> parameter now correctly stores "User" instead of "Option" in TypeEnv Integration tests with fixtures for Java Optional, Rust Option, C++ auto chain. Full pipeline resolution marked .todo — requires call-processor enhancement (TypeEnv stores correct types but call-processor needs additional work to produce CALLS edges for these patterns). Unit tests: 196 passed (7 new). Integration: all 9 languages green. * fix: resolve .todo tests — stale dist/ was the root cause The Rust Option<User> and C++ auto assignment chain integration tests were marked .todo because the pipeline didn't produce CALLS edges. Root cause: dist/ was compiled from pre-Phase 4 source and lacked: - NULLABLE_WRAPPER_TYPES unwrapping in extractSimpleTypeName - C++ extractPendingAssignment After npm run build, all tests pass as real assertions: - Rust: alias.save() resolves to User#save via Option<User> unwrap + chain - C++: alias.save() and rAlias.save() resolve via auto assignment chain with correct disambiguation (User vs Repo) Only remaining .todo: Rust user.unwrap().save() (Phase 5 — chained return type inference, not a TypeEnv issue).	2026-03-16 15:21:54 +00:00
Gergő Magyar	62242d5f44	feat: TypeEnvironment API with constructor inference, self/this/super resolution (#274) ... * feat(type-env): constructor-call type inference for TypeEnv (Phase 1) Add extractInitializer as a Tier 1 fallback in buildTypeEnv: when a declaration node has no explicit type annotation, infer the type from constructor-call patterns (new X(), X::new(), X::default(), $x = new X()). Languages covered: TypeScript/JS, Java (var), Rust, PHP, C++ (auto). Python/Kotlin/Swift deferred — need symbol-table access to distinguish class constructors from function calls. Adds 20 new unit tests covering constructor inference, annotation precedence, and known limitations across all supported languages. * fix(type-env): class-aware constructor resolution, multi-declarator fix - Add collectClassNames pre-scan: walks AST to build Set<string> of class/struct names defined in the file - C++ extractInitializer uses classNames.has() to verify identifier is a known class before inferring (auto x = User() resolves, auto x = getUser() does not — no false positives) - Add InitializerExtractor type that receives classNames parameter - Fix env.size gating: always call extractInitializer when available, so mixed declarators like const a: A = x, b = new B() resolve both - Add env.has() guard in Java extractInitializer to skip already-bound vars - Document Rust new/default whitelist rationale - Pin all test assertions, add mixed multi-declarator test case * fix(type-env): resolve Self/self/static/parent to actual type names - Rust: Self::new()/Self::default() resolves to enclosing impl type - PHP: new self()/static() resolves to enclosing class, parent() to superclass - Rust: Tier 0 annotation guard prevents overwrite by constructor inference - Rust: mut_pattern handling in extractVarName for let mut bindings - TS: fix misleading comment in extractInitializer - 58 tests passing (3 new Self/self resolution tests) * perf(type-env): single-pass AST walk with closure-scoped state Refactors buildTypeEnv to use closures instead of passing mutable state as parameters. classNames, env, and config are captured by the inner walk and extractTypeBinding functions — no parameter mutation. - Eliminates separate collectClassNames pre-scan (O(2n) → O(n)) - config looked up once per file instead of per-node - 29 fewer lines * feat(type-env): constructor-inferred type resolution for all languages Add cross-file constructor type inference to the ingestion pipeline, enabling receiver-type disambiguation for member calls like `user.save()` when the variable is assigned from a constructor without explicit type annotations. Pipeline changes: - Add extractInitializer to Python and Swift type extractors - Add CONSTRUCTOR_BINDING_SCANNERS for Python, Swift, C/C++ in type-env - Wire constructorBindings through parse-worker → parsing-processor → pipeline → processCallsFromExtracted - Rewrite resolveCallTarget receiver-type filtering (step D) to use tiered import resolution (same-file → import-scoped → global) before falling back to fuzzy ownerId matching - Use collectTieredCandidates for constructor binding verification instead of raw lookupFuzzy Bug fixes: - Fix C++ inline method query: @definition.method was captured on field_declaration_list instead of function_definition, causing wrong parameterCount for all inline class methods - Fix parse-worker accumulated/flush results missing constructorBindings CI changes: - Add swift.test.ts to ci-integration pipeline group and coverage job - Update ci-report to fetch base branch (main) coverage for delta reporting instead of showing config thresholds - Add per-suite timing breakdown table (unit/integration/total) - Add expandable skipped test details section Tests: 288 passed, 4 skipped (swift — macOS only) across 10 languages - 36 new constructor-inferred integration tests (4 per language) - 10 fixture directories with cross-file constructor patterns - TypeScript, JavaScript, Java, Kotlin, Python, PHP, Rust, Go, C++, Swift * fix(type-extractors): add type assertion for LanguageTypeConfig * feat(ruby): constructor-inferred type resolution and self-receiver mapping Add Ruby User.new constructor binding scanner to type-env, enabling receiver-type disambiguation for member calls like user.save vs repo.save. Add self/this → enclosing class resolution in lookupTypeEnv so self.method() calls resolve to the correct class even when the method name is ambiguous. * docs: update README with constructor inference and self/this resolution details * refactor(ingestion): unified ResolutionContext replaces fragmented map passing Introduce createResolutionContext() as the single resolution API for all processors. Eliminates duplicated tier-selection logic, fixes heritage namedImportMap bug, and adds per-file resolution caching. - NEW resolution-context.ts: closure-factory with resolve(), per-file cache, TIER_CONFIDENCE constant, and shared ResolutionTier type - DELETE symbol-resolver.ts: zero production importers, logic now in resolution-context.ts - call-processor: all functions take ctx instead of 6 separate maps, collectTieredCandidates removed (ctx.resolve replaces it), D4 redundant re-resolve eliminated - heritage-processor: takes ctx, resolveHeritageId helper extracts repeated 14-line fallback pattern, namedImportMap now included - import-processor: takes ctx, dead createImportMap/createPackageMap/ createNamedImportMap factories removed - pipeline: creates single ctx, wires onProgress to all processors, logs cache hit rate in dev mode - Tier renamed: unique-global → global (honest about returning all candidates) - Tests migrated: 1178 unit + 84 integration passing * feat(type-env): self/this/super resolution, TypeEnvironment API, and review fixes Add cross-language receiver keyword resolution: - self/this/$this → enclosing class name via AST walk - super/base/parent → parent class name via heritage AST extraction (8 grammar variants: TS/JS, Java, Python, Ruby, C#, PHP, Kotlin, C++, Swift) - D-phase widening in resolveCallTarget for super→parent method dispatch Introduce TypeEnvironment API replacing loose TypeEnvResult + lookupTypeEnv: - buildTypeEnv() returns TypeEnvironment with .lookup() method - Single-pass AST walk merges constructor binding scan (was separate traversal) - ClassNameLookup type replaces over-broad ReadonlySet<string> facade - Memoized class name lookups to avoid redundant SymbolTable scans Code review fixes (6 agents, 11 findings): - Replace ctx.resolve(name, '') hack with direct symbols.lookupFuzzy() - Extract scope key helpers (extractFuncNameFromScope, receiverKey) - Simplify D-phase from 5 steps to 4 with deduped typeNodeIds - Remove C from CONSTRUCTOR_BINDING_SCANNERS (YAGNI — C has no constructors) - Cache Map reuse in ResolutionContext to reduce GC pressure - Remove unused TieredCandidates import Integration tests for self/this, parent, and super resolution across all 12 supported languages with per-language fixture directories. * fix(type-env): generic parent resolution, TS cast inference, C++ brace-init Fix generic parent class breaking super resolution: - extractParentClassFromNode now uses extractSimpleTypeName to strip generic params (Base<T> → Base) and qualified names (models.Model → Model) - Affects TS, Java, Python, C# heritage extraction Fix TypeScript new X() as T / new X()! missed inference: - Unwrap as_expression and non_null_expression before checking for new_expression in extractInitializer Fix C++ brace-init User{} missed inference: - Handle compound_literal_expression with type_identifier child in extractInitializer Clean up deprecated lookupTypeEnv: - Remove standalone lookupTypeEnv export, migrate all callers to TypeEnvironment.lookup() method - Update all 80+ test assertions to use the new API Integration test fixtures added: - typescript-cast-constructor-inference (new X() as T, new X()!) - typescript/java/csharp/kotlin-generic-parent-resolution - cpp-brace-init-inference (auto x = User{}) * fix(type-extractors): Go &User{}, TS double-cast, Swift .init inference Fix Go pointer-to-struct literal not inferred: - Unwrap unary_expression (address-of &) before composite_literal check - user := &User{} now correctly infers type User Fix TypeScript double-cast only unwrapping one level: - Change if to while loop for nested as_expression/non_null_expression - new User() as unknown as Admin now correctly infers type User Fix Swift User.init(name:) explicit init call missed: - Handle navigation_expression callee with .init suffix in extractInitializer Integration test fixtures: - go-pointer-constructor-inference (&User{}, &Repo{}) - typescript-double-cast-inference (as unknown as T) * feat: Rust struct literal, Python qualified ctor, Go new(), Swift .init scanner - Rust: handle struct_expression in extractInitializer (User { name: "alice" }) - Python: support attribute nodes in extractInitializer (models.User("alice")) and the cross-file scanner — extractSimpleTypeName handles qualified names - Go: handle new(User) built-in in extractGoShortVarDeclaration - Swift: extend CONSTRUCTOR_BINDING_SCANNERS to handle navigation_expression callee for User.init(name:) cross-file resolution Unit tests: 87 → 96 (Rust struct literal, Go new(), Python qualified ctor, Python scanner qualified, plus edge cases) Integration tests: 4 new describe blocks with fixtures * fix: Rust Self{} resolution, C++ scoped brace-init, PHP promotion params, Ruby constants - Rust: resolve Self {} struct literal to enclosing impl type (was stored as "Self") - C++: replace type_identifier guard with extractSimpleTypeName for compound_literal_expression, enabling ns::User{} scoped brace-init (closes previously deferred gap) - PHP: add property_promotion_parameter to TYPED_PARAMETER_TYPES for PHP 8.0+ constructor property promotion (__construct(private Foo $x)) - Ruby: extend extractRubyConstructorBinding to accept constant left-hand side (REPO = Repo.new) Unit tests: 96 → 101 (+5: Rust Self{} ×2, C++ ns::User{} ×1, PHP promotion ×1, Ruby constant ×1) Integration tests: 4 new describe blocks with fixtures * feat: Phase 1 type resolution gaps — walrus, PHP properties, nullable, Go make/assert Phase 1 quick wins from the type resolution gap analysis: 1. Python walrus operator := (named_expression) — extractInitializer + scanner 2. PHP 7.4+ typed class properties — property_declaration in extractDeclaration 3. Nullable union unwrapping — User | null → User in extractSimpleTypeName 4. Go make() builtin — slice/map element type extraction 5. Go type assertions — iface.(User) type extraction Also: PHP primitive_type handling in extractSimpleTypeName (string, int, etc.) Unit tests: 101 → 114 (+13) Integration tests: 8 new describe blocks with fixtures * feat: Phase 2 type resolution gaps — C++ range-for, Rust if-let, C# pattern matching, Python class annotations Phase 2 medium-effort improvements: 1. C++ range-for with explicit type — for (User& u : vec) binds u: User 2. Rust if-let/while-let captured_pattern — user @ User { .. } binds user: User 3. C# is-pattern matching — if (obj is User user) binds user: User 4. Python class-level annotations — confirmed already working, added tests Unit tests: 114 → 127 (+13) Integration tests: 11 new test cases with fixtures	2026-03-14 19:05:49 +00:00