code2llm 0.5.49__tar.gz → 0.5.50__tar.gz

{code2llm-0.5.49 → code2llm-0.5.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.49
+Version: 0.5.50
 Summary: High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries
 Home-page: https://github.com/wronai/stts
 Author: STTS Project
@@ -60,7 +60,7 @@ When you run `code2llm ./ -f all`, the following files are created:
 
 | File | Format | Purpose | Key Insights |
 |------|--------|---------|--------------|
-| `analysis.toon` | **TOON** | **🔥 Health diagnostics** - Complexity, god modules, coupling | 59 critical functions, 0 god modules |
+| `analysis.toon` | **TOON** | **🔥 Health diagnostics** - Complexity, god modules, coupling | 61 critical functions, 0 god modules |
 | `project.toon` | **TOON** | **🧠 Project logic** - Compact module view from code2logic | Generated via code2logic integration |
 
 ### 🤖 LLM-Ready Documentation
@@ -375,7 +375,7 @@ code2llm ./ -f yaml --separate-orphans
 
 **Generated by**: `code2llm ./ -f all --readme`  
 **Analysis Date**: 2026-03-09  
-**Total Functions**: 854  
+**Total Functions**: 857  
 **Total Classes**: 104  
 **Modules**: 105  
 

{code2llm-0.5.49 → code2llm-0.5.50}/README.md

@@ -10,7 +10,7 @@ When you run `code2llm ./ -f all`, the following files are created:
 
 | File | Format | Purpose | Key Insights |
 |------|--------|---------|--------------|
-| `analysis.toon` | **TOON** | **🔥 Health diagnostics** - Complexity, god modules, coupling | 59 critical functions, 0 god modules |
+| `analysis.toon` | **TOON** | **🔥 Health diagnostics** - Complexity, god modules, coupling | 61 critical functions, 0 god modules |
 | `project.toon` | **TOON** | **🧠 Project logic** - Compact module view from code2logic | Generated via code2logic integration |
 
 ### 🤖 LLM-Ready Documentation
@@ -325,7 +325,7 @@ code2llm ./ -f yaml --separate-orphans
 
 **Generated by**: `code2llm ./ -f all --readme`  
 **Analysis Date**: 2026-03-09  
-**Total Functions**: 854  
+**Total Functions**: 857  
 **Total Classes**: 104  
 **Modules**: 105  
 

{code2llm-0.5.49 → code2llm-0.5.50}/code2llm/__init__.py

@@ -8,7 +8,7 @@ Includes NLP Processing Pipeline for query normalization, intent matching,
 and entity resolution with multilingual support.
 """
 
-__version__ = "0.5.49"
+__version__ = "0.5.50"
 __author__ = "STTS Project"
 
 # Core analysis components (lightweight, always needed)

{code2llm-0.5.49 → code2llm-0.5.50}/code2llm/core/core/file_analyzer.py

@@ -140,6 +140,120 @@ class FileAnalyzer:
             if self.config.verbose:
                 print(f"Error calculating complexity for {file_path}: {e}")
 
+    # ------------------------------------------------------------------
+    # Universal regex-based complexity & call extraction (non-Python)
+    # ------------------------------------------------------------------
+
+    # Branching keywords per language family
+    _CC_PATTERNS = {
+        'c_family': re.compile(
+            r'\b(?:if|else\s+if|for|while|do|switch|case|catch|&&|\|\||\?\?|\?\.)\b'
+            r'|\?\s*[^:]*\s*:'  # ternary
+        ),
+        'go': re.compile(
+            r'\b(?:if|for|switch|case|select|go|defer)\b'
+            r'|&&|\|\|'
+        ),
+        'rust': re.compile(
+            r'\b(?:if|else\s+if|for|while|loop|match|=>)\b'
+            r'|&&|\|\||\?'
+        ),
+    }
+
+    @staticmethod
+    def _extract_function_body(content: str, start_line: int) -> str:
+        """Extract the body of a function between braces from a start line (1-indexed)."""
+        lines = content.split('\n')
+        if start_line < 1 or start_line > len(lines):
+            return ''
+        depth = 0
+        body_lines = []
+        started = False
+        for line in lines[start_line - 1:]:
+            for ch in line:
+                if ch == '{':
+                    depth += 1
+                    started = True
+                elif ch == '}':
+                    depth -= 1
+            if started:
+                body_lines.append(line)
+            if started and depth <= 0:
+                break
+        return '\n'.join(body_lines)
+
+    def _calculate_complexity_regex(self, content: str, result: Dict,
+                                    lang: str = 'c_family') -> None:
+        """Estimate cyclomatic complexity for every function using regex keyword counting."""
+        pattern = self._CC_PATTERNS.get(lang, self._CC_PATTERNS['c_family'])
+        for func_info in result['functions'].values():
+            body = self._extract_function_body(content, func_info.line)
+            if not body:
+                cc = 1
+            else:
+                cc = 1 + len(pattern.findall(body))
+            rank = 'A' if cc <= 5 else ('B' if cc <= 10 else ('C' if cc <= 20 else 'D'))
+            func_info.complexity = {
+                'cyclomatic_complexity': cc,
+                'cc_rank': rank,
+            }
+
+    _CALL_PATTERN_C_FAMILY = re.compile(
+        r'(?<!\bfunction\b\s)'            # not a function declaration
+        r'(?<!\bclass\b\s)'               # not a class declaration
+        r'\b([a-zA-Z_]\w*)\s*\('          # simple call: foo(
+        r'|'
+        r'(?:this|self)\s*\.\s*(\w+)\s*\('  # this.method( / self.method(
+        r'|'
+        r'\b(\w+)\s*\.\s*(\w+)\s*\('      # obj.method(
+    )
+
+    def _extract_calls_regex(self, content: str, module_name: str, result: Dict) -> None:
+        """Extract function calls from function bodies using regex."""
+        # Build set of known function simple names for resolution
+        known_simple: Dict[str, List[str]] = {}
+        for qname in result['functions']:
+            simple = qname.rsplit('.', 1)[-1]
+            known_simple.setdefault(simple, []).append(qname)
+
+        for func_qname, func_info in result['functions'].items():
+            body = self._extract_function_body(content, func_info.line)
+            if not body:
+                continue
+            calls_seen = set()
+            for m in self._CALL_PATTERN_C_FAMILY.finditer(body):
+                simple_call = m.group(1) or m.group(2) or m.group(4)
+                if not simple_call:
+                    continue
+                # Skip language keywords
+                if simple_call in ('if', 'for', 'while', 'switch', 'catch',
+                                   'return', 'throw', 'new', 'typeof', 'instanceof',
+                                   'import', 'export', 'require', 'console',
+                                   'super', 'class', 'function', 'async', 'await',
+                                   'delete', 'void', 'case', 'default'):
+                    continue
+                # Resolve to known qualified name
+                if simple_call in known_simple:
+                    candidates = known_simple[simple_call]
+                    # Prefer same-module match
+                    resolved = None
+                    my_module = func_qname.rsplit('.', 1)[0]
+                    for cand in candidates:
+                        if cand.rsplit('.', 1)[0] == my_module:
+                            resolved = cand
+                            break
+                    if resolved is None:
+                        resolved = candidates[0]
+                    if resolved != func_qname and resolved not in calls_seen:
+                        func_info.calls.append(resolved)
+                        calls_seen.add(resolved)
+                else:
+                    # External call — store as module.name for downstream
+                    ext_name = f"{module_name}.{simple_call}"
+                    if ext_name not in calls_seen:
+                        func_info.calls.append(ext_name)
+                        calls_seen.add(ext_name)
+
     def _perform_deep_analysis(self, tree: ast.AST, module_name: str, file_path: str, result: Dict) -> None:
         """Perform deep analysis including DFG and call graph extraction."""
         try:
@@ -397,22 +511,48 @@ class FileAnalyzer:
         
         # Patterns for TypeScript/JavaScript
         import_pattern = re.compile(r"^\s*import\s+.*?\s+from\s+['\"]([^'\"]+)['\"]")
-        class_pattern = re.compile(r"^\s*(?:export\s+)?(?:default\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{]+))?")
+        class_pattern = re.compile(r"^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{]+))?")
         func_pattern = re.compile(r"^\s*(?:export\s+)?(?:async\s+)?(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?[\(\w])")
         interface_pattern = re.compile(r"^\s*(?:export\s+)?interface\s+(\w+)")
+        # Class method patterns: shorthand methods, getters, setters, arrow props
+        method_pattern = re.compile(
+            r"^\s*(?:(?:public|private|protected|static|readonly|abstract|async|override)\s+)*"
+            r"(?:get\s+|set\s+)?"
+            r"(\w+)\s*(?:<[^>]*>)?\s*\([^)]*\)"
+        )
+        arrow_prop_pattern = re.compile(
+            r"^\s*(?:(?:public|private|protected|static|readonly)\s+)*"
+            r"(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>"
+        )
         
         current_class = None
-        current_class_line = 0
+        class_brace_depth = 0
+        brace_depth = 0
         
         for line_no, line in enumerate(lines, 1):
+            raw_line = line
             line = line.strip()
             if not line or line.startswith('//') or line.startswith('/*') or line.startswith('*'):
+                # Still track braces in comments? No — skip them
                 continue
             
+            # Track brace depth for class scope
+            for ch in raw_line:
+                if ch == '{':
+                    brace_depth += 1
+                elif ch == '}':
+                    brace_depth -= 1
+            
+            # End of class scope
+            if current_class and brace_depth < class_brace_depth:
+                current_class = None
+                class_brace_depth = 0
+            
             # Imports
             import_match = import_pattern.match(line)
             if import_match:
                 result['module'].imports.append(import_match.group(1))
+                continue
             
             # Classes
             class_match = class_pattern.match(line)
@@ -438,7 +578,8 @@ class FileAnalyzer:
                 result['module'].classes.append(qualified_name)
                 self.stats['classes_found'] += 1
                 current_class = qualified_name
-                current_class_line = line_no
+                class_brace_depth = brace_depth
+                continue
             
             # Interfaces (treat as classes)
             interface_match = interface_pattern.match(line)
@@ -457,21 +598,14 @@ class FileAnalyzer:
                 )
                 result['module'].classes.append(qualified_name)
                 self.stats['classes_found'] += 1
+                continue
             
-            # Functions
+            # Standalone functions (function declarations & const/let/var arrows)
             func_match = func_pattern.match(line)
-            if func_match:
+            if func_match and not current_class:
                 func_name = func_match.group(1) or func_match.group(2)
                 if func_name:
-                    if current_class and line_no > current_class_line:
-                        # Method
-                        method_name = func_name
-                        qualified_name = f"{current_class}.{method_name}"
-                        result['classes'][current_class].methods.append(qualified_name)
-                    else:
-                        # Standalone function
-                        qualified_name = f"{module_name}.{func_name}"
-                    
+                    qualified_name = f"{module_name}.{func_name}"
                     result['functions'][qualified_name] = FunctionInfo(
                         name=func_name,
                         qualified_name=qualified_name,
@@ -479,8 +613,8 @@ class FileAnalyzer:
                         line=line_no,
                         column=0,
                         module=module_name,
-                        class_name=current_class.split('.')[-1] if current_class else None,
-                        is_method=current_class is not None,
+                        class_name=None,
+                        is_method=False,
                         is_private=func_name.startswith('_'),
                         is_property=False,
                         docstring="",
@@ -489,6 +623,58 @@ class FileAnalyzer:
                     )
                     result['module'].functions.append(qualified_name)
                     self.stats['functions_found'] += 1
+                    continue
+            
+            # Class members: methods (shorthand syntax) & arrow property methods
+            if current_class:
+                _matched_method = False
+                # Arrow property: myMethod = (args) => { ... }
+                arrow_match = arrow_prop_pattern.match(line)
+                if arrow_match:
+                    method_name = arrow_match.group(1)
+                    if method_name not in ('constructor', 'if', 'for', 'while', 'switch', 'return'):
+                        _matched_method = True
+                
+                # Shorthand method: myMethod(args) { ... }
+                if not _matched_method:
+                    meth_match = method_pattern.match(line)
+                    if meth_match:
+                        method_name = meth_match.group(1)
+                        if method_name not in ('if', 'for', 'while', 'switch', 'return',
+                                               'catch', 'class', 'import', 'export', 'new'):
+                            _matched_method = True
+                
+                # Also catch const/let/var arrows inside class (rare but valid)
+                if not _matched_method and func_match:
+                    fname = func_match.group(1) or func_match.group(2)
+                    if fname:
+                        method_name = fname
+                        _matched_method = True
+                
+                if _matched_method:
+                    qualified_name = f"{current_class}.{method_name}"
+                    result['classes'][current_class].methods.append(qualified_name)
+                    result['functions'][qualified_name] = FunctionInfo(
+                        name=method_name,
+                        qualified_name=qualified_name,
+                        file=file_path,
+                        line=line_no,
+                        column=0,
+                        module=module_name,
+                        class_name=current_class.split('.')[-1],
+                        is_method=True,
+                        is_private=method_name.startswith('_') or method_name.startswith('#'),
+                        is_property=False,
+                        docstring="",
+                        args=[],
+                        decorators=[],
+                    )
+                    result['module'].functions.append(qualified_name)
+                    self.stats['functions_found'] += 1
+        
+        # Regex-based complexity estimation and call extraction
+        self._calculate_complexity_regex(content, result, lang='c_family')
+        self._extract_calls_regex(content, module_name, result)
         
         self.stats['files_processed'] += 1
         return result
@@ -566,6 +752,10 @@ class FileAnalyzer:
                 result['module'].classes.append(qualified_name)
                 self.stats['classes_found'] += 1
         
+        # Regex-based complexity estimation and call extraction
+        self._calculate_complexity_regex(content, result, lang='go')
+        self._extract_calls_regex(content, module_name, result)
+        
         self.stats['files_processed'] += 1
         return result
 
@@ -649,6 +839,10 @@ class FileAnalyzer:
                 result['module'].classes.append(qualified_name)
                 self.stats['classes_found'] += 1
         
+        # Regex-based complexity estimation and call extraction
+        self._calculate_complexity_regex(content, result, lang='rust')
+        self._extract_calls_regex(content, module_name, result)
+        
         self.stats['files_processed'] += 1
         return result
 
@@ -734,6 +928,10 @@ class FileAnalyzer:
                     result['classes'][current_class].methods.append(qualified_name)
                     self.stats['functions_found'] += 1
         
+        # Regex-based complexity estimation and call extraction
+        self._calculate_complexity_regex(content, result, lang='c_family')
+        self._extract_calls_regex(content, module_name, result)
+        
         self.stats['files_processed'] += 1
         return result
 

{code2llm-0.5.49 → code2llm-0.5.50}/code2llm/nlp/__init__.py

@@ -4,7 +4,7 @@ Provides query normalization, intent matching, and entity resolution
 with multilingual support and fuzzy matching.
 """
 
-__version__ = "0.5.49"
+__version__ = "0.5.50"
 
 from .pipeline import NLPPipeline
 from .normalization import QueryNormalizer

{code2llm-0.5.49 → code2llm-0.5.50}/code2llm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.49
+Version: 0.5.50
 Summary: High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries
 Home-page: https://github.com/wronai/stts
 Author: STTS Project
@@ -60,7 +60,7 @@ When you run `code2llm ./ -f all`, the following files are created:
 
 | File | Format | Purpose | Key Insights |
 |------|--------|---------|--------------|
-| `analysis.toon` | **TOON** | **🔥 Health diagnostics** - Complexity, god modules, coupling | 59 critical functions, 0 god modules |
+| `analysis.toon` | **TOON** | **🔥 Health diagnostics** - Complexity, god modules, coupling | 61 critical functions, 0 god modules |
 | `project.toon` | **TOON** | **🧠 Project logic** - Compact module view from code2logic | Generated via code2logic integration |
 
 ### 🤖 LLM-Ready Documentation
@@ -375,7 +375,7 @@ code2llm ./ -f yaml --separate-orphans
 
 **Generated by**: `code2llm ./ -f all --readme`  
 **Analysis Date**: 2026-03-09  
-**Total Functions**: 854  
+**Total Functions**: 857  
 **Total Classes**: 104  
 **Modules**: 105  
 

{code2llm-0.5.49 → code2llm-0.5.50}/code2llm.egg-info/SOURCES.txt

@@ -94,6 +94,7 @@ tests/test_flow_exporter.py
 tests/test_format_quality.py
 tests/test_multilanguage_e2e.py
 tests/test_nlp_pipeline.py
+tests/test_nonpython_cc_calls.py
 tests/test_pipeline_detector.py
 tests/test_prompt_engine.py
 tests/test_prompt_txt.py

{code2llm-0.5.49 → code2llm-0.5.50}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2llm"
-version = "0.5.49"
+version = "0.5.50"
 description = "High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries"
 readme = "README.md"
 requires-python = ">=3.8"

code2llm-0.5.50/tests/test_nonpython_cc_calls.py

@@ -0,0 +1,312 @@
+"""Regression tests for non-Python cyclomatic complexity and call graph extraction.
+
+Verifies that TypeScript, JavaScript, Go, Rust, and Java files get proper
+CC values (not all zeros) and call graph edges extracted.
+"""
+
+import tempfile
+from pathlib import Path
+from code2llm.core.analyzer import ProjectAnalyzer
+from code2llm.core.config import Config, FAST_CONFIG
+
+
+class TestTypeScriptComplexityAndCalls:
+    """Verify TS/JS files get CC > 0 and call edges."""
+
+    TS_CODE = """\
+import { Logger } from './logger';
+
+class UserService {
+    private users: any[] = [];
+
+    constructor() {
+        this.users = [];
+    }
+
+    addUser(user: any): void {
+        if (user && user.name) {
+            if (user.age > 0) {
+                this.users.push(user);
+            } else {
+                throw new Error('invalid age');
+            }
+        }
+    }
+
+    findUser(id: number): any {
+        for (const u of this.users) {
+            if (u.id === id) {
+                return u;
+            }
+        }
+        return null;
+    }
+
+    processAll(): void {
+        for (const u of this.users) {
+            if (u.active || u.admin) {
+                this.notify(u);
+            }
+        }
+    }
+
+    notify(user: any): void {
+        console.log(user.name);
+    }
+}
+
+function initService(): UserService {
+    const svc = new UserService();
+    return svc;
+}
+
+export function main(): void {
+    const svc = initService();
+    if (svc) {
+        svc.processAll();
+    }
+}
+"""
+
+    def _analyze(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            ts_file = Path(tmpdir) / "user_service.ts"
+            ts_file.write_text(self.TS_CODE)
+            analyzer = ProjectAnalyzer(FAST_CONFIG)
+            return analyzer.analyze_project(tmpdir)
+
+    def test_ts_functions_detected(self):
+        result = self._analyze()
+        func_names = {f.name for f in result.functions.values()}
+        # Should detect class methods (shorthand syntax) + standalone functions
+        assert 'addUser' in func_names, f"addUser not found in {func_names}"
+        assert 'findUser' in func_names, f"findUser not found in {func_names}"
+        assert 'processAll' in func_names, f"processAll not found in {func_names}"
+        assert 'notify' in func_names, f"notify not found in {func_names}"
+        assert 'initService' in func_names, f"initService not found in {func_names}"
+        assert 'main' in func_names, f"main not found in {func_names}"
+
+    def test_ts_complexity_not_zero(self):
+        result = self._analyze()
+        ccs = {}
+        for name, fi in result.functions.items():
+            cc = fi.complexity.get('cyclomatic_complexity', 0)
+            ccs[fi.name] = cc
+
+        # addUser has if/if/else → CC should be > 1
+        assert ccs.get('addUser', 0) > 1, f"addUser CC should be > 1, got {ccs.get('addUser')}"
+        # findUser has for/if → CC > 1
+        assert ccs.get('findUser', 0) > 1, f"findUser CC should be > 1, got {ccs.get('findUser')}"
+        # processAll has for/if/|| → CC > 1
+        assert ccs.get('processAll', 0) > 1, f"processAll CC should be > 1, got {ccs.get('processAll')}"
+        # notify is trivial → CC = 1
+        assert ccs.get('notify', 0) >= 1, f"notify CC should be >= 1, got {ccs.get('notify')}"
+
+    def test_ts_calls_extracted(self):
+        result = self._analyze()
+        all_calls = {}
+        for name, fi in result.functions.items():
+            simple_calls = [c.rsplit('.', 1)[-1] for c in fi.calls]
+            all_calls[fi.name] = simple_calls
+
+        # processAll calls notify
+        assert 'notify' in all_calls.get('processAll', []), \
+            f"processAll should call notify, got {all_calls.get('processAll')}"
+        # main calls initService
+        assert 'initService' in all_calls.get('main', []), \
+            f"main should call initService, got {all_calls.get('main')}"
+
+    def test_ts_cc_avg_not_zero(self):
+        result = self._analyze()
+        total_cc = sum(
+            fi.complexity.get('cyclomatic_complexity', 0)
+            for fi in result.functions.values()
+        )
+        count = len(result.functions)
+        assert count > 0
+        avg = total_cc / count
+        assert avg > 1.0, f"Average CC should be > 1.0 for non-trivial code, got {avg:.2f}"
+
+
+class TestGoComplexityAndCalls:
+    """Verify Go files get CC > 0."""
+
+    GO_CODE = """\
+package main
+
+import "fmt"
+
+type Server struct {
+    port int
+}
+
+func (s *Server) Start() error {
+    if s.port <= 0 {
+        return fmt.Errorf("invalid port")
+    }
+    for i := 0; i < 3; i++ {
+        if i > 1 {
+            fmt.Println("retrying")
+        }
+    }
+    return nil
+}
+
+func NewServer(port int) *Server {
+    return &Server{port: port}
+}
+
+func main() {
+    s := NewServer(8080)
+    if err := s.Start(); err != nil {
+        fmt.Println(err)
+    }
+}
+"""
+
+    def _analyze(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            go_file = Path(tmpdir) / "main.go"
+            go_file.write_text(self.GO_CODE)
+            analyzer = ProjectAnalyzer(FAST_CONFIG)
+            return analyzer.analyze_project(tmpdir)
+
+    def test_go_complexity_not_zero(self):
+        result = self._analyze()
+        ccs = {fi.name: fi.complexity.get('cyclomatic_complexity', 0)
+               for fi in result.functions.values()}
+        # Start has if/for/if → CC > 1
+        assert ccs.get('Start', 0) > 1, f"Start CC should be > 1, got {ccs.get('Start')}"
+        # main has if → CC > 1
+        assert ccs.get('main', 0) > 1, f"main CC should be > 1, got {ccs.get('main')}"
+
+    def test_go_calls_extracted(self):
+        result = self._analyze()
+        all_calls = {}
+        for fi in result.functions.values():
+            all_calls[fi.name] = [c.rsplit('.', 1)[-1] for c in fi.calls]
+        # main calls NewServer
+        assert 'NewServer' in all_calls.get('main', []), \
+            f"main should call NewServer, got {all_calls.get('main')}"
+
+
+class TestRustComplexityAndCalls:
+    """Verify Rust files get CC > 0."""
+
+    RUST_CODE = """\
+use std::collections::HashMap;
+
+struct Config {
+    values: HashMap<String, String>,
+}
+
+impl Config {
+    fn get(&self, key: &str) -> Option<&String> {
+        if key.is_empty() {
+            return None;
+        }
+        self.values.get(key)
+    }
+
+    fn set(&mut self, key: &str, value: &str) {
+        if key.is_empty() || value.is_empty() {
+            return;
+        }
+        self.values.insert(key.to_string(), value.to_string());
+    }
+}
+
+fn load_config() -> Config {
+    Config { values: HashMap::new() }
+}
+
+fn main() {
+    let mut cfg = load_config();
+    cfg.set("key", "value");
+    if let Some(v) = cfg.get("key") {
+        println!("{}", v);
+    }
+}
+"""
+
+    def _analyze(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            rs_file = Path(tmpdir) / "main.rs"
+            rs_file.write_text(self.RUST_CODE)
+            analyzer = ProjectAnalyzer(FAST_CONFIG)
+            return analyzer.analyze_project(tmpdir)
+
+    def test_rust_complexity_not_zero(self):
+        result = self._analyze()
+        ccs = {fi.name: fi.complexity.get('cyclomatic_complexity', 0)
+               for fi in result.functions.values()}
+        # set has if/|| → CC > 1
+        assert ccs.get('set', 0) > 1, f"set CC should be > 1, got {ccs.get('set')}"
+        # get has if → CC > 1
+        assert ccs.get('get', 0) > 1, f"get CC should be > 1, got {ccs.get('get')}"
+
+
+class TestJavaComplexityAndCalls:
+    """Verify Java files get CC > 0."""
+
+    JAVA_CODE = """\
+import java.util.List;
+import java.util.ArrayList;
+
+public class UserService {
+    private List<String> users;
+
+    public UserService() {
+        this.users = new ArrayList<>();
+    }
+
+    public void addUser(String name) {
+        if (name != null && !name.isEmpty()) {
+            users.add(name);
+        }
+    }
+
+    public String findUser(String prefix) {
+        for (String u : users) {
+            if (u.startsWith(prefix)) {
+                return u;
+            }
+        }
+        return null;
+    }
+
+    public int countActive(boolean includeAdmin) {
+        int count = 0;
+        for (String u : users) {
+            if (u.startsWith("active") || (includeAdmin && u.startsWith("admin"))) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
+"""
+
+    def _analyze(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            java_file = Path(tmpdir) / "UserService.java"
+            java_file.write_text(self.JAVA_CODE)
+            analyzer = ProjectAnalyzer(FAST_CONFIG)
+            return analyzer.analyze_project(tmpdir)
+
+    def test_java_complexity_not_zero(self):
+        result = self._analyze()
+        ccs = {fi.name: fi.complexity.get('cyclomatic_complexity', 0)
+               for fi in result.functions.values()}
+        # addUser has if/&& → CC > 1
+        assert ccs.get('addUser', 0) > 1, f"addUser CC should be > 1, got {ccs.get('addUser')}"
+        # findUser has for/if → CC > 1
+        assert ccs.get('findUser', 0) > 1, f"findUser CC should be > 1, got {ccs.get('findUser')}"
+        # countActive has for/if/||/&& → CC > 1
+        assert ccs.get('countActive', 0) > 1, f"countActive CC should be > 1, got {ccs.get('countActive')}"
+
+    def test_java_calls_extracted(self):
+        result = self._analyze()
+        # At least some calls should be detected
+        total_calls = sum(len(fi.calls) for fi in result.functions.values())
+        assert total_calls > 0, "Java should have some call edges detected"