2 commits

Author	SHA1	Message	Date
Gergő Magyar	f0132c1077	feat: Phase 6 type resolution — for-loop Tier 1c, pattern matching, container descriptors, 10-language coverage (#318) ... * feat: Phase 6 type resolution — pattern matching, for-loop Tier 1c, coverage completion - Add patternBindingNodeTypes gate to LanguageTypeConfig for 50% perf improvement - Expand ForLoopExtractor signature with optional declarationTypeNodes + scope - Add extractElementTypeFromString shared utility for container type parsing - Python match/case: extractPatternBinding for `case User() as u:` pattern - C# refactor: move is_pattern_expression from extractDeclaration to extractPatternBinding - Ruby: add extractPendingAssignment for assignment chain propagation - TS/JS: add for-loop Tier 1c for `for (const user of users)` with User[] inference - Python: add for-loop Tier 1c for `for user in users:` with type annotation inference - Go: add for-loop Tier 1c for `for _, user := range users` with []User inference - Fix 'Property' as any stale cast in call-processor.ts - Add dual return-type string length cap (2048 pre-cap, 512 post-cap) - Add chain call integration tests for C#, Go, Rust, Python, JS, C++ - Add Python match/case integration test fixtures - 27 new extractElementTypeFromString unit tests - 3 for-loop edge cases skipped (declarationTypeNodes scope key lookup) * fix: address code review findings for Phase 6 - Add missing patternBindingNodeTypes to C# typeConfig (perf gate) - Add 2048-char input length guard to extractElementTypeFromString - Skip Python match/case integration tests (call extraction needs query updates) * reorganise * fix: Phase 1 bug fixes — Go range semantics, typed_parameter, bracket depth - Go single-var range correctly returns early for slices/maps (index, not element) - Go single-var range on channels correctly resolves element type - Added map_type and channel_type to extractGoElementTypeFromTypeNode - Added isChannelType helper for channel detection before skip decision - Added 'typed_parameter' to TYPED_PARAMETER_TYPES for Python annotated params - Fixed bracket depth tracking in extractElementTypeFromString — only match selected closeChar at depth 0, return undefined for mismatched brackets - Un-skipped 3 prematurely skipped tests (TS local const, Python List/Sequence) - Added tests for map range, single-var range semantics, bracket edge cases * refactor: Phase 2 architecture — shared helper, required params, decoupled type nodes - Extract resolveIterableElementType shared helper in shared.ts implementing 3-strategy fallback (declarationTypeNodes → scopeEnv string → AST walk) - Refactor TS, Python, Go extractors to use shared helper (eliminates 3x duplication) - Make ForLoopExtractor params required (aligned with PatternBindingExtractor) - Update Java, Kotlin, C# extractor signatures to accept required params - Decouple declarationTypeNodes from scopeEnv — capture raw type annotation nodes BEFORE extractDeclaration for container types (User[], []User, List[User]) - Hybrid approach: direct name extraction + keysBefore fallback for multi-declarator - Document declarationTypeNodes invariant change (superset of scopeEnv) * feat: Phase 3 partial — Rust for-loop + C# var foreach Tier 1c - Rust: add extractForLoopBinding with for_expression support - Handles &users, &mut users via reference_expression unwrapping - extractRustElementTypeFromTypeNode: generic_type, reference_type, slice/array - findRustParamElementType: AST walk with reference/mut pattern unwrapping - 4 unit tests (Vec<User>, &[User], range expr negative, no-annotation negative) - C#: upgrade foreach to handle var (implicit_type) via Tier 1c - extractCSharpElementTypeFromTypeNode: generic_name, array_type, nullable_type - findCSharpParamElementType: AST walk to method_declaration parameters - 3 unit tests (var foreach, explicit type regression, no-annotation negative) * feat: Phase 3 complete — all language gaps + pattern matching Kotlin Tier 1c: - Unannotated for-loop resolves via shared helper - extractKotlinElementTypeFromTypeNode handles type_projection unwrapping - findKotlinParamElementType walks to function_declaration Java Tier 1c: - var foreach resolves via shared helper - extractJavaElementTypeFromTypeNode handles generic_type, array_type - findJavaParamElementType walks to method_declaration TypeScript: - readonly User[] unwrapped via readonly_type → array_type recursion C# switch patterns: - declaration_pattern added to patternBindingNodeTypes - extractPatternBinding handles standalone declaration_pattern (switch case/expr) Rust match arms: - match_arm added to patternBindingNodeTypes - extractPatternBinding extended with match_arm → match_expression parent traversal Python: - as_pattern tries childForFieldName('alias') before positional fallback Tests: 237 pass (was 224), 13 new tests added * feat: Phase 4 — known limitation tests, match arm fix, final verification - Fix Rust match_arm pattern extraction: unwrap match_pattern to get tuple_struct_pattern inside (tree-sitter-rust wraps in match_pattern node) - Add first-writer-wins regression test for match arm scope leakage - Add 5 documented skip tests for known limitations: - TS destructured for-of (tuple destructuring) - Python tuple unpacking in for-loops - TS instanceof narrowing (block-level scoping) - Rust for with .iter() (method call iterable) - Ruby block parameters (closure param inference) Final: 238 passed, 5 skipped (documented limitations), tsc clean * test: integration tests for all Phase 6 language gaps + fix Rust param pattern field Integration test fixtures and tests (30 new tests, all with exact match + negative): Rust for-loop (5 tests): - for user in &users with Vec<User> → User#save, negative Repo#save - for repo in &repos with Vec<Repo> → Repo#save, negative User#save Rust match arm (5 tests): - match opt { Some(user) => user.save() } → User#save, negative Repo#save - if let Ok(repo) = res → Repo#save, negative User#save C# var foreach (5 tests): - foreach (var user in users) with List<User> → User#Save, negative Repo#Save - foreach (var repo in repos) with List<Repo> → Repo#Save C# switch pattern (4 tests): - is User user → User#Save, case Repo repo → Repo#Save Kotlin unannotated for (4 tests): - for (user in users) with List<User> → user.save, negative repo.save Go map range (3 tests): - for _, user := range userMap with map[string]User → User#Save, negative TypeScript readonly (4 tests): - for (const user of users) with readonly User[] → user.save, negative Bug fix: type-env.ts parameter branch now falls back to childForFieldName('pattern') for Rust parameters (Rust uses 'pattern' not 'name' for parameter names) * test: add assertion bodies to known limitation skip tests Convert empty skip test stubs to proper tests with parse/buildTypeEnv/expect assertions following the codebase convention (e.g., call-processor.test.ts:319). Each skip test now documents the exact expected behavior, so removing .skip will cause a meaningful failure when the limitation is eventually fixed. Also clarify Python integration skip tests as call-extraction issues (not type-env) and Swift integration skips as build-dep issues (self/super resolution code already exists in type-env.ts). * feat: resolve 4 known limitation skip tests + method-aware type arg selection Unskip 4 of 5 type-env known limitations with full integration test coverage: 1. TS destructured for-of: handle array_pattern by binding last named child to element type. Fix Map<K,V> to return last generic arg (value type). 2. Python dict.items() loop: handle `call` iterables + `pattern_list` left side. Fix dict[K,V] extraction via type_parameter with last-arg heuristic. Unwrap `type` wrapper in extractPyElementTypeFromAnnotation. 3. TS instanceof narrowing: add extractPatternBinding for binary_expression with positional child access. First-writer-wins (not block-scoped). 4. Rust .iter() for-loops: handle call_expression in for_expression value node by extracting receiver from field_expression. Method-aware type arg resolution: - Add TypeArgPosition ('first'|'last') to resolveIterableElementType - .keys()/.keySet()/.Keys → first type arg (key); all else → last (value) - Thread position through all 3 strategy callbacks in TS/Rust/Python - Add predefined_type to extractSimpleTypeName for TS primitives (string etc) New fixtures: rust-iter-for-loop, typescript-destructured-for-of, typescript-instanceof-narrowing, python-dict-items-loop. 248 unit tests pass (6 new), 1 skip (Ruby block params). * feat: container descriptor table for generic type arg resolution Replace simple KEY_METHODS heuristic with CONTAINER_DESCRIPTORS table that maps 30+ container types across all languages to their type parameter semantics per access method. Key improvements: - Container-aware resolution: HashMap.iter() correctly yields V (arity 2), while Vec.iter() yields T (arity 1) — same method, different semantics - Cross-language coverage: Map/HashMap/BTreeMap/dict/Dict/Dictionary/ ConcurrentHashMap + List/Vec/Set/HashSet/Queue/Deque/Stack etc. - Method categorization: keyMethods (keys/keySet/Keys) vs valueMethods (values/get/pop/iter/first/last) per container type - Fallback for unknown containers: still uses method name heuristic, so MyCache<K,V>.keys() correctly returns first arg - Exported getContainerDescriptor() for future heritage-chain lookups Each language extractor now passes containerTypeName from scopeEnv to methodToTypeArgPosition for descriptor-aware resolution. 252 unit tests pass (4 new descriptor tests), 1 skip (Ruby). * feat: method-aware for-loop extractors + integration tests for all languages Upgrade 4 existing extractors + create 3 new ones for full cross-language coverage of call_expression iterables and container descriptor resolution: Upgraded (add call expr iterable + methodToTypeArgPosition): - Java: method_invocation (data.keySet(), data.values()) - Kotlin: navigation_expression + call_expression (data.keys, data.values()) - C#: member_access_expression + invocation_expression (data.Keys, data.Values) - Go: TypeArgPosition threading for Go 1.18+ generics New for-loop extractors: - C++: for_range_loop with auto& unwrapping, template_type + qualified_identifier (std::vector<User>) extraction, explicit vs auto type handling - PHP: foreach_statement with simple/key-value/by-reference forms, PHPDoc @param priority over AST array type - Ruby: for-in with YARD @param type resolution via comment parsing Integration test fixtures + tests for all 6 languages: - java-map-keys-values (Map.values() + List iteration) - kotlin-map-keys-values (HashMap.values + List iteration) - csharp-dictionary-keys-values (Dictionary.Values foreach) - cpp-range-for (auto& + const auto& range-based for) - php-foreach-loop (foreach with PHPDoc @param User[]) - ruby-for-in-loop (for-in with YARD @param Array<User>) Bugs fixed during integration testing: - C++: qualified_identifier (std::vector) not unwrapped to template_type - PHP: extractParameter overwrote PHPDoc-derived types with bare 'array' 252 unit tests pass, 201 integration tests pass across 6 languages. * fix: update extractElementTypeFromString tests for last-arg default TypeArgPosition change (default 'last') broke 5 existing tests expecting first arg from multi-arg generics. Updated expectations and added explicit pos='first' tests for key type extraction. * fix: rename C++ fixture files to correct case for case-sensitive CI On case-sensitive filesystems (Linux/macOS CI), git tracked both the old lowercase files (app.cpp, user.h) and the new uppercase files (App.cpp, User.h) as separate files. The pipeline processed both, causing the old app.cpp (with explicit User& type) to interfere with the new auto& test. Removes old lowercase entries and re-adds with uppercase casing to match the #include directives in the fixture. * feat: PR #318 review findings — pattern bindings, member access iterables, structured bindings Address all 7 genuine gaps identified in PR #318 deep code review: - Kotlin: add extractKotlinPatternBinding for when/is (type_test AST node) with allowPatternBindingOverwrite for smart-cast semantics - Java: add type_pattern branch for Java 17+ switch pattern variables - TypeScript: explicit object_pattern skip in for-of (no false bindings) - Cross-language: member access iterables (self.users, this.users, repo.users) across all 10 language extractors - C++: structured_binding_declarator handling in range-for (last-child heuristic) - Rust: closure_parameter added to TYPED_PARAMETER_TYPES - PHP: normalizePhpType handles angle-bracket generics (Collection<User>) Code review fixes applied: - Remove 4 debug console.log statements (c-cpp.ts, call-processor.ts) - Hoist KNOWN_CONTAINER_PROPS to module scope (csharp.ts) - Guard keysBefore allocation behind typeNode check (type-env.ts) - Add depth limits (50) to 7 recursive type extraction functions - Add 2048-char length cap to extractSimpleTypeName - Fix PHP/Ruby missing typeArgPos parameter in resolveIterableElementType Integration test fixtures: kotlin-when-pattern, java-switch-pattern, cpp-structured-binding, typescript-member-access-for-loop, python-member-access-for-loop * fix: position-indexed when/is bindings, Kotlin param extraction, HashMap.values for-loop Three root causes for failing Kotlin integration tests: 1. When/is multi-arm resolution: flat scopeEnv stored only the last arm's type (last-writer-wins). Added PatternOverrides with AST range indexing so each when arm resolves to its narrowed type independently. 2. HashMap.values for-loop: navigation_expression without call_suffix was classified as bare property access (iterableName='values' instead of 'data'). Now tries object-as-iterable + property-as-method first, with fallback to property-as-iterable for this.users patterns. 3. Kotlin parameter extraction: tree-sitter-kotlin parameter nodes use positional children (simple_identifier, user_type) not named fields (name, type). Added fallback to findChildByType in both extractKotlinParameter and extractTypeBinding. Integration tests added for .keys/.values/Set/MutableMap iteration, 3-arm when/is, multi-call within arms, and when+else branch. * feat: enhance PHP type resolution for generics and member access in foreach loops * feat: Phase 6.1 type resolution gap closure — container descriptors, recursive_pattern, class fields Add 13 missing container type descriptors (Collection, MutableMap, Stream, SortedSet, etc.) to CONTAINER_DESCRIPTORS for correct element type extraction across C#, Kotlin, and Java. Extend C# pattern binding to handle recursive_pattern (obj is User { Name: "Alice" } u) in both is-expression and switch expression contexts. Add TypeScript class field declaration support (public_field_definition) so for-loop iteration over this.fieldName resolves element types from class field type annotations. Includes file-scope fallback in resolveIterableElementType and nested member_expression handling for this.field.method() patterns. * docs: add type resolution system documentation with roadmap Covers the full architecture, resolution tiers (0-2), scope model, language feature matrix, container descriptors, pipeline integration, and the Phase 7-9 roadmap for cross-scope propagation, field-type resolution, and return-type-aware binding. * feat: Phase 6.2 review findings — C# nested member foreach, C++ deref range-for, Java field_access Close two gaps found during fourth-pass review of PR #318: - C# foreach (var user in this.data.Values): nested member_access_expression now extracts intermediate property name for scopeEnv lookup - C++ for (auto& user : *ptr): pointer_expression dereference now recognized as range-for iterable Root causes fixed in shared infrastructure: - extractSimpleTypeName: add template_type (C++) and generic_name (C#) - extractGenericTypeArgs: add generic_name for consistency - type-env.ts: unwrap variable_declaration wrapper in field_declaration for declarationTypeNodes capture (zero-allocation manual loop) Additional review findings addressed: - Java: add field_access handler for this.data.values() in method_invocation - C++ pointer_expression: document limitation (*identifier only) - TypeScript: fix stale comment about property_identifier All 525 tests pass (278 unit + 247 integration). * perf: optimize type resolution pipeline — worker threshold, skip graph phases, AST pruning - Skip worker pool creation for small repos (<15 files or <512KB) — saves 100-400ms - Add skipGraphPhases option to runPipelineFromRepo to skip MRO/community/process phases - Add conservative SKIP_SUBTREE_TYPES for leaf-only AST nodes (string, comment, number) - Pre-compute interestingNodeTypes set — single Set.has() replaces 3 checks per node - Add fastStripNullable — skip full stripNullable for simple identifiers (90%+ case) - Replace .children?.find() with manual for loops in extractFunctionName (no array alloc) - Add hookTimeout: 120000 to vitest.config.ts for CI beforeAll hooks * fix: review findings — remove template_string from SKIP_SUBTREE_TYPES, handle bare nullable keywords - Remove template_string and concatenated_string from SKIP_SUBTREE_TYPES (template literals contain interpolated expressions with typed code) - Add FAST_NULLABLE_KEYWORDS check to fastStripNullable for behavioral parity with stripNullable on bare null/undefined/void/None/nil - Add explanatory comment on extractPendingAssignment scopeEnv guard * feat: add type resolution system and roadmap documentation	2026-03-17 17:10:22 +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