graphitect 0.2.0__py3-none-any.whl

graphify/extractors/dart.py

@@ -0,0 +1,564 @@
+"""Dart extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+import re
+
+from pathlib import Path
+from graphify.extractors.base import _file_stem, _make_id
+
+
+def extract_dart(path: Path) -> dict:
+    """Extract classes, mixins, functions, imports, generic calls, and annotations from a .dart file using regex."""
+    try:
+        src = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return {"error": f"cannot read {path}"}
+
+    # Remove inline and multi-line comments while leaving string literals untouched to prevent stripping URLs/paths inside strings
+    comment_string_pattern = re.compile(
+        r'"""(?:\\.|[\s\S])*?"""'
+        r"|'''(?:\\.|[\s\S])*?'''"
+        r'|"(?:\\.|[^"\\])*"'
+        r"|'(?:\\.|[^'\\])*'"
+        r"|/\*[\s\S]*?\*/"
+        r"|//[^\n]*"
+    )
+    def _comment_replace(match: re.Match) -> str:
+        token = match.group(0)
+        if token.startswith("/"):
+            # Blank to the SAME number of newlines the comment spanned, not
+            # to an empty string: every offset computed against src_clean
+            # below (including every source_location line number) is only
+            # valid if src_clean's line count tracks the original file's.
+            # Deleting a multi-line comment outright shifted every later
+            # line number up by the comment's own height (#3365).
+            return "\n" * token.count("\n")
+        return token
+    src_clean = comment_string_pattern.sub(_comment_replace, src)
+
+    def _line_at(offset: int) -> int:
+        return src_clean[:offset].count("\n") + 1
+
+    stem = _file_stem(path)
+    file_nid = _make_id(str(path))
+
+    # Check if this is a part-of file and redirect to parent
+    part_of_match = re.search(r"^\s*part\s+of\s+['\"]([^'\"]+)['\"]", src_clean, re.MULTILINE)
+    is_part = False
+    if part_of_match:
+        parent_ref = part_of_match.group(1)
+        if parent_ref.endswith(".dart"):
+            try:
+                parent_path = (path.parent / parent_ref).resolve()
+                if parent_path.exists():
+                    stem = _file_stem(parent_path)
+                    file_nid = _make_id(str(parent_path))
+                    is_part = True
+            except Exception:
+                pass
+
+    nodes = []
+    if not is_part:
+        nodes.append({"id": file_nid, "label": path.name, "file_type": "code",
+                      "source_file": str(path), "source_location": None})
+    edges = []
+    defined: set[str] = set()
+
+    def add_node(nid: str, label: str, ftype: str = "code", source_file: str | None = str(path),
+                 line: int | None = None) -> None:
+        if nid not in defined:
+            nodes.append({"id": nid, "label": label, "file_type": ftype,
+                          "source_file": source_file,
+                          "source_location": f"L{line}" if line else None})
+            defined.add(nid)
+
+    def add_edge(src_id: str, tgt_id: str, relation: str, weight: float = 1.0, context: str | None = None,
+                 line: int | None = None) -> None:
+        edge = {"source": src_id, "target": tgt_id, "relation": relation,
+                "confidence": "EXTRACTED", "confidence_score": 1.0,
+                "source_file": str(path),
+                "source_location": f"L{line}" if line else None, "weight": weight}
+        if context:
+            edge["context"] = context
+        edges.append(edge)
+
+    def _split_types(text: str) -> list[str]:
+        parts = []
+        current = []
+        depth = 0
+        for char in text:
+            if char == "<":
+                depth += 1
+                current.append(char)
+            elif char == ">":
+                depth -= 1
+                current.append(char)
+            elif char == "," and depth == 0:
+                parts.append("".join(current).strip())
+                current = []
+            else:
+                current.append(char)
+        if current:
+            parts.append("".join(current).strip())
+        return [p for p in parts if p]
+
+    def _find_matching_brace(text: str, start_pos: int) -> int:
+        brace_count = 0
+        in_double_quote = False
+        in_single_quote = False
+        escape = False
+
+        first_brace = text.find("{", start_pos)
+        if first_brace == -1:
+            return len(text)
+
+        brace_count = 1
+        i = first_brace + 1
+        n = len(text)
+        while i < n:
+            char = text[i]
+            if escape:
+                escape = False
+                i += 1
+                continue
+            if char == "\\":
+                escape = True
+                i += 1
+                continue
+            if text[i:i+3] == '"""' and not in_single_quote:
+                i += 3
+                end = text.find('"""', i)
+                i = end + 3 if end != -1 else n
+                continue
+            if text[i:i+3] == "'''" and not in_double_quote:
+                i += 3
+                end = text.find("'''", i)
+                i = end + 3 if end != -1 else n
+                continue
+            if char == '"' and not in_single_quote:
+                in_double_quote = not in_double_quote
+            elif char == "'" and not in_double_quote:
+                in_single_quote = not in_single_quote
+            elif not in_double_quote and not in_single_quote:
+                if char == "{":
+                    brace_count += 1
+                elif char == "}":
+                    brace_count -= 1
+                    if brace_count == 0:
+                        return i + 1
+            i += 1
+        return len(text)
+
+    # 1. Classes, mixins, and enums declarations (with inheritance, mixins, interfaces, and generics)
+    # Supports multiple combined modifiers (e.g., abstract base class, mixin class) without capturing "class" as a name
+    class_pattern = r"^\s*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+(\w+)"
+    for m in re.finditer(class_pattern, src_clean, re.MULTILINE):
+        class_name = m.group(1)
+        # Anchor on the capture group, not the whole match: the pattern's
+        # leading ^\s* makes m.start() land before the blank/indent lines
+        # that precede the declaration, reporting the line too early (#3365).
+        class_line = _line_at(m.start(1))
+        class_nid = _make_id(stem, class_name)
+        add_node(class_nid, class_name, line=class_line)
+        add_edge(file_nid, class_nid, "defines", line=class_line)
+
+        # Manually parse extends/on, with, and implements in header to handle nested generics brackets balanced
+        start_idx = m.end()
+        rest = src_clean[start_idx : start_idx + 500]
+
+        # Skip class generic parameters
+        if rest.lstrip().startswith("<"):
+            offset = rest.find("<")
+            depth = 1
+            i = offset + 1
+            while i < len(rest) and depth > 0:
+                if rest[i] == "<": depth += 1
+                elif rest[i] == ">": depth -= 1
+                i += 1
+            rest = rest[i:]
+
+        # Skip primary constructor (e.g. extension type MyExt(int id))
+        if rest.lstrip().startswith("("):
+            offset = rest.find("(")
+            depth = 1
+            i = offset + 1
+            while i < len(rest) and depth > 0:
+                if rest[i] == "(": depth += 1
+                elif rest[i] == ")": depth -= 1
+                i += 1
+            rest = rest[i:]
+
+        header_end = rest.find("{")
+        if header_end == -1:
+            header_end = rest.find(";")
+        if header_end == -1:
+            header_end = len(rest)
+        header = rest[:header_end]
+
+        base_class = None
+        generics = None
+        mixins_list = []
+        interfaces_list = []
+
+        # Parse extends or on
+        extends_m = re.search(r"^\s*(?:extends|on)\s+([a-zA-Z0-9_.]+)", header)
+        if extends_m:
+            base_class = extends_m.group(1)
+            rest_header = header[extends_m.end():]
+            if rest_header.strip().startswith("<"):
+                start_idx = rest_header.find("<")
+                depth = 1
+                i = start_idx + 1
+                while i < len(rest_header) and depth > 0:
+                    if rest_header[i] == "<":
+                        depth += 1
+                    elif rest_header[i] == ">":
+                        depth -= 1
+                        if depth == 0:
+                            generics = rest_header[start_idx + 1 : i]
+                            break
+                    i += 1
+                if generics is not None:
+                    header = rest_header[i + 1:]
+                else:
+                    header = rest_header
+            else:
+                header = rest_header
+
+        # Parse with
+        with_m = re.search(r"^\s*with\s+", header)
+        if with_m:
+            rest_header = header[with_m.end():]
+            impl_idx = rest_header.find("implements")
+            if impl_idx != -1:
+                mixins_str = rest_header[:impl_idx]
+                header = rest_header[impl_idx:]
+            else:
+                mixins_str = rest_header
+                header = ""
+            mixins_list = _split_types(mixins_str)
+
+        # Parse implements
+        impl_m = re.search(r"^\s*implements\s+", header)
+        if impl_m:
+            interfaces_list = _split_types(header[impl_m.end():])
+
+        # Map extends inheritance relation
+        if base_class:
+            base_nid = _make_id(base_class)
+            add_node(base_nid, base_class, source_file=None)
+            add_edge(class_nid, base_nid, "inherits", line=class_line)
+
+            # Map generic type arguments (e.g. MyBloc extends Bloc<MyEvent, MyState>)
+            if generics:
+                for gen in _split_types(generics):
+                    gen_clean = gen.split("<")[0].strip()
+                    if gen_clean not in {"String", "int", "double", "bool", "num", "dynamic", "Object", "void"}:
+                        gen_nid = _make_id(gen_clean)
+                        add_node(gen_nid, gen_clean, source_file=None)
+                        add_edge(class_nid, gen_nid, "references", line=class_line)
+
+        # Map mixins
+        for mixin in mixins_list:
+            mixin_clean = mixin.split("<")[0].strip()
+            mixin_nid = _make_id(mixin_clean)
+            add_node(mixin_nid, mixin_clean, source_file=None)
+            add_edge(class_nid, mixin_nid, "mixes_in", line=class_line)
+
+        # Map interfaces
+        for interface in interfaces_list:
+            interface_clean = interface.split("<")[0].strip()
+            interface_nid = _make_id(interface_clean)
+            add_node(interface_nid, interface_clean, source_file=None)
+            add_edge(class_nid, interface_nid, "implements", line=class_line)
+
+        # Extract class body for precise framework dependencies and event handling
+        start_idx = m.start()
+        brace_pos = src_clean.find("{", start_idx)
+        semi_pos = src_clean.find(";", start_idx)
+
+        has_body = brace_pos != -1
+        if has_body and semi_pos != -1 and semi_pos < brace_pos:
+            has_body = False
+
+        if has_body:
+            end_pos = _find_matching_brace(src_clean, start_idx)
+            class_body = src_clean[brace_pos:end_pos]
+
+            # Bloc event registration: on<MyEvent>()
+            for em in re.finditer(r"\bon<(\w+)>\s*\(", class_body):
+                event_name = em.group(1)
+                event_nid = _make_id(event_name)
+                add_node(event_nid, event_name, source_file=None)
+                add_edge(class_nid, event_nid, "calls", context="bloc_event",
+                          line=_line_at(brace_pos + em.start(1)))
+
+            # Bloc state emissions: emit(MyState) or yield MyState
+            for sm in re.finditer(r"\b(?:emit|yield)\s*\(?\s*(?:const\s+)?([A-Z]\w*)\b", class_body):
+                state_name = sm.group(1)
+                if state_name not in {"String", "List", "Map", "Set", "Future", "Stream", "Object"}:
+                    state_nid = _make_id(state_name)
+                    add_node(state_nid, state_name, source_file=None)
+                    add_edge(class_nid, state_nid, "calls", context="emit_state",
+                              line=_line_at(brace_pos + sm.start(1)))
+
+            # Bloc event additions: widget.add(MyEvent()) or bloc.add(MyEvent())
+            for am in re.finditer(r"\b(?:\w*[Bb]loc\w*|context\.read<\w+>\(\))\.add\(\s*(?:const\s+)?([A-Z]\w*)\b", class_body):
+                event_name = am.group(1)
+                if event_name not in {"String", "List", "Map", "Set", "Future", "Stream", "Object"}:
+                    event_nid = _make_id(event_name)
+                    add_node(event_nid, event_name, source_file=None)
+                    add_edge(class_nid, event_nid, "calls", context="bloc_add_event",
+                              line=_line_at(brace_pos + am.start(1)))
+
+            # Riverpod provider references: ref.watch(provider)
+            for rm in re.finditer(r"\bref\.(?:watch|read|listen)\s*\(\s*(\w+)\b", class_body):
+                provider_name = rm.group(1)
+                provider_nid = _make_id(provider_name)
+                add_node(provider_nid, provider_name, source_file=None)
+                add_edge(class_nid, provider_nid, "references", context="riverpod_reference",
+                          line=_line_at(brace_pos + rm.start(1)))
+
+            # Widget to Bloc references: BlocBuilder<MyBloc, ...>
+            for bm in re.finditer(r"\bBloc(?:Builder|Listener|Consumer|Provider|Selector)\s*<\s*([a-zA-Z0-9_]+)\b", class_body):
+                bloc_name = bm.group(1)
+                if bloc_name not in {"String", "int", "double", "bool", "num", "dynamic", "Object", "void"}:
+                    bloc_nid = _make_id(bloc_name)
+                    add_node(bloc_nid, bloc_name, source_file=None)
+                    add_edge(class_nid, bloc_nid, "references", context="bloc_widget_binding",
+                              line=_line_at(brace_pos + bm.start(1)))
+
+            # context.read<MyBloc>() or BlocProvider.of<MyBloc>(context)
+            for lm in re.finditer(r"\b(?:read|watch|select|of)\s*<([a-zA-Z0-9_]+)>", class_body):
+                bloc_name = lm.group(1)
+                if bloc_name not in {"String", "int", "double", "bool", "num", "dynamic", "Object", "void"}:
+                    bloc_nid = _make_id(bloc_name)
+                    add_node(bloc_nid, bloc_name, source_file=None)
+                    add_edge(class_nid, bloc_nid, "references", context="bloc_lookup",
+                              line=_line_at(brace_pos + lm.start(1)))
+
+    # 2. Annotations mapping (class, mixin, enum, or function level annotations)
+    # Support: @riverpod, @Riverpod(...), @injectable, @singleton, @RoutePage(), @HiveType(typeId: 0), @RestApi()
+    # Matches `@annotation` and links it to the next class/mixin/enum/function declaration in the file
+    annotation_pattern = r"@(\w+)(?:\([^)]*\))?"
+    for am in re.finditer(annotation_pattern, src_clean):
+        annotation_name = am.group(1)
+        if annotation_name in {"override", "deprecated", "required", "protected", "mustCallSuper"}:
+            continue
+        annotation_pos = am.end()
+        intervening_text = src_clean[annotation_pos : annotation_pos + 300]
+
+        class_m = re.search(r"^\s*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+(\w+)", intervening_text, re.MULTILINE)
+        func_m = re.search(r"^\s*(?:factory\s+|static\s+|async\s+|external\s+|abstract\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+(\w+)\s*\(", intervening_text, re.MULTILINE)
+
+        target_nid = None
+        target_name = None
+        target_type = None
+
+        if class_m and func_m:
+            if class_m.start() < func_m.start():
+                target_name = class_m.group(1)
+                target_type = "class"
+                target_nid = _make_id(stem, target_name)
+            else:
+                target_name = func_m.group(1)
+                target_type = "function"
+                target_nid = _make_id(stem, target_name)
+        elif class_m:
+            target_name = class_m.group(1)
+            target_type = "class"
+            target_nid = _make_id(stem, target_name)
+        elif func_m:
+            target_name = func_m.group(1)
+            target_type = "function"
+            target_nid = _make_id(stem, target_name)
+
+        if target_nid and target_name:
+            actual_intervening = intervening_text[:min(class_m.start() if class_m else 300, func_m.start() if func_m else 300)]
+            if ";" not in actual_intervening and "}" not in actual_intervening and "{" not in actual_intervening:
+                annotation_line = _line_at(am.start(1))
+                annotation_nid = _make_id("annotation", annotation_name.lower())
+                add_node(annotation_nid, f"@{annotation_name}", ftype="concept", source_file=None)
+                add_edge(target_nid, annotation_nid, "configures", line=annotation_line)
+
+                # Riverpod specific provider generation mapping (supports camelCase class and functional providers)
+                if annotation_name.lower() == "riverpod":
+                     if target_type == "class":
+                         provider_name = target_name[0].lower() + target_name[1:] + "Provider" if len(target_name) > 1 else target_name.lower() + "Provider"
+                     else:
+                         provider_name = target_name + "Provider"
+                     provider_nid = _make_id(provider_name)
+                     add_node(provider_nid, provider_name, ftype="concept", source_file=str(path), line=annotation_line)
+                     add_edge(target_nid, provider_nid, "defines", context="riverpod_provider", line=annotation_line)
+
+    # 2.5 Typedefs (Type Aliases)
+    typedef_pattern = r"^\s*typedef\s+(\w+)\s*(?:<[^>]+>)?\s*=\s*([a-zA-Z0-9_<>,.?\s]+);"
+    for m in re.finditer(typedef_pattern, src_clean, re.MULTILINE):
+        typedef_name = m.group(1)
+        typedef_line = _line_at(m.start(1))
+        target_type = m.group(2).split("<")[0].split(".")[-1].strip()
+        if target_type not in {"String", "int", "double", "bool", "num", "dynamic", "Object", "List", "Map", "Set", "void", "Function"}:
+            typedef_nid = _make_id(stem, typedef_name)
+            add_node(typedef_nid, typedef_name, line=typedef_line)
+            add_edge(file_nid, typedef_nid, "defines", line=typedef_line)
+            target_nid = _make_id(target_type)
+            add_node(target_nid, target_type, source_file=None)
+            add_edge(typedef_nid, target_nid, "references", context="typedef", line=typedef_line)
+
+    # 3. Extensions (extension MyExt on MyClass)
+    ext_pattern = r"^\s{0,4}extension\s+(\w+)?(?:<[^>]+>)?\s+on\s+(\w+)"
+    for m in re.finditer(ext_pattern, src_clean, re.MULTILINE):
+        ext_name = m.group(1) or f"{stem}_anonymous_extension"
+        target_class = m.group(2)
+        ext_line = _line_at(m.start(2))
+
+        ext_nid = _make_id(stem, ext_name)
+        label = m.group(1) or f"Extension on {target_class}"
+        add_node(ext_nid, label, line=ext_line)
+        add_edge(file_nid, ext_nid, "defines", line=ext_line)
+
+        target_nid = _make_id(target_class)
+        add_node(target_nid, target_class, source_file=None)
+        add_edge(ext_nid, target_nid, "extends", line=ext_line)
+
+    # 4. Top-level and class-level variable declarations (generic variables, records, late, and destructuring)
+    # Restrict indentation to 0-2 spaces to avoid matching local variables inside functions or switch expressions
+    var_pattern = r"^\s{0,2}(?:late\s+)?(?:(?:final|const|var)\s+)?(?:\([^)]+\)\s+|([a-zA-Z0-9_<>,.?]+(?:\s+[a-zA-Z0-9_<>,.?]+){0,3})\s+)?(?:(\w+)|(?:\w+\s*)?\(([^)]+)\))\s*(?:=|$|;)"
+    for m in re.finditer(var_pattern, src_clean, re.MULTILINE):
+        var_type = m.group(1)
+        single_name = m.group(2)
+        destructured_names = m.group(3)
+
+        if not re.match(r"^\s*(?:late|final|const|var)\b", m.group(0)) and not var_type:
+            continue
+
+        if single_name:
+            if single_name not in {"if", "for", "while", "switch", "catch", "return"}:
+                var_line = _line_at(m.start(2))
+                var_nid = _make_id(stem, single_name)
+                add_node(var_nid, single_name, line=var_line)
+                add_edge(file_nid, var_nid, "defines", line=var_line)
+
+                if var_type and var_type not in {"String", "int", "double", "bool", "num", "dynamic", "Object", "List", "Map", "Set", "void"}:
+                    clean_type = var_type.split("<")[0].split(".")[-1].strip()
+                    type_nid = _make_id(clean_type)
+                    add_node(type_nid, clean_type, source_file=None)
+                    add_edge(file_nid, type_nid, "references", context="variable_type", line=var_line)
+        elif destructured_names:
+            destructure_line = _line_at(m.start(3))
+            for name in [n.strip() for n in destructured_names.split(",") if n.strip()]:
+                if ":" in name:
+                    name = name.split(":")[-1].strip()
+                if re.match(r"^[a-zA-Z_]\w*$", name) and not re.match(r"^[A-Z]", name):
+                    if name not in {"if", "for", "while", "switch", "catch", "return"}:
+                        var_nid = _make_id(stem, name)
+                        add_node(var_nid, name, line=destructure_line)
+                        add_edge(file_nid, var_nid, "defines", line=destructure_line)
+
+    # 5. Top-level and member functions/methods (supports typed/generic/record return types and Riverpod/Bloc references)
+    # Restrict indentation to 0-2 spaces to avoid matching nested local functions or methods inside multiline switch statements
+    method_pattern = r"^\s{0,2}(?:factory\s+|static\s+|async\s+|external\s+|abstract\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+(\w+(?:\.\w+)?)\s*\("
+    for m in re.finditer(method_pattern, src_clean, re.MULTILINE):
+        raw_name = m.group(1)
+        name = raw_name.split(".")[-1]
+        if name in {"if", "for", "while", "switch", "catch", "return", "void", "dynamic", "final", "const", "get", "set"}:
+            continue
+        if re.match(r"^[A-Z]", name):
+            continue
+        method_line = _line_at(m.start(1))
+        nid = _make_id(stem, name)
+        add_node(nid, name, line=method_line)
+        add_edge(file_nid, nid, "defines", line=method_line)
+
+        # Get function body using matching brace to extract Riverpod reference patterns
+        start_idx = m.start()
+        brace_pos = src_clean.find("{", start_idx)
+        semi_pos = src_clean.find(";", start_idx)
+        arrow_pos = src_clean.find("=>", start_idx)
+
+        has_body = brace_pos != -1
+        if has_body and semi_pos != -1 and semi_pos < brace_pos:
+            has_body = False
+        if has_body and arrow_pos != -1 and arrow_pos < brace_pos:
+            has_body = False
+
+        if has_body:
+            end_pos = _find_matching_brace(src_clean, start_idx)
+            func_body = src_clean[brace_pos:end_pos]
+
+            # Extract Riverpod provider references: ref.watch(provider)
+            for rm in re.finditer(r"\bref\.(?:watch|read|listen)\s*\(\s*(\w+)\b", func_body):
+                provider_name = rm.group(1)
+                provider_nid = _make_id(provider_name)
+                add_node(provider_nid, provider_name, source_file=None)
+                add_edge(nid, provider_nid, "references", context="riverpod_reference",
+                          line=_line_at(brace_pos + rm.start(1)))
+
+            # Extract Bloc event additions: widget.add(MyEvent()) or bloc.add(MyEvent())
+            for am in re.finditer(r"\b(?:\w*[Bb]loc\w*|context\.read<\w+>\(\))\.add\(\s*(?:const\s+)?([A-Z]\w*)\b", func_body):
+                event_name = am.group(1)
+                if event_name not in {"String", "List", "Map", "Set", "Future", "Stream", "Object"}:
+                    event_nid = _make_id(event_name)
+                    add_node(event_nid, event_name, source_file=None)
+                    add_edge(nid, event_nid, "calls", context="bloc_add_event",
+                              line=_line_at(brace_pos + am.start(1)))
+
+            # context.read<MyBloc>() or BlocProvider.of<MyBloc>(context)
+            for lm in re.finditer(r"\b(?:read|watch|select|of)\s*<([a-zA-Z0-9_]+)>", func_body):
+                bloc_name = lm.group(1)
+                if bloc_name not in {"String", "int", "double", "bool", "num", "dynamic", "Object", "void"}:
+                    bloc_nid = _make_id(bloc_name)
+                    add_node(bloc_nid, bloc_name, source_file=None)
+                    add_edge(nid, bloc_nid, "references", context="bloc_lookup",
+                              line=_line_at(brace_pos + lm.start(1)))
+
+            # Universal Navigation Patters (GoRouter, AutoRoute, Navigator)
+            for nm in re.finditer(r"\b(?:go|push|goNamed|pushNamed|replace|replaceNamed)\s*\(\s*(?:context\s*,\s*)?['\"]([a-zA-Z0-9_/?=&%-]+)['\"]", func_body):
+                route_path = nm.group(1)
+                route_nid = _make_id("route", route_path.replace("/", "_").replace("?", "_").replace("=", "_").replace("&", "_"))
+                add_node(route_nid, f"Route {route_path}", ftype="concept", source_file=None)
+                add_edge(nid, route_nid, "navigates", context="route_path",
+                          line=_line_at(brace_pos + nm.start(1)))
+
+            for cm in re.finditer(r"\b(?:go|push|goNamed|pushNamed|replace|replaceNamed)\s*\(\s*(?:context\s*,\s*)?([A-Z][a-zA-Z0-9_]*\.[a-zA-Z0-9_]+)", func_body):
+                route_const = cm.group(1)
+                route_nid = _make_id("route", route_const.replace(".", "_"))
+                add_node(route_nid, route_const, ftype="concept", source_file=None)
+                add_edge(nid, route_nid, "navigates", context="route_const",
+                          line=_line_at(brace_pos + cm.start(1)))
+
+            for om in re.finditer(r"\b(?:push|replace)\s*\(\s*(?:context\s*,\s*)?.*?\b([A-Z]\w*(?:Route|Screen|Page))\b", func_body):
+                route_class = om.group(1)
+                route_nid = _make_id(route_class)
+                add_node(route_nid, route_class, source_file=None)
+                add_edge(nid, route_nid, "navigates", context="route_object",
+                          line=_line_at(brace_pos + om.start(1)))
+
+    # 6. Imports and Exports
+    for m in re.finditer(r"""^\s*import\s+['"]([^'"]+)['"]""", src_clean, re.MULTILINE):
+        pkg = m.group(1)
+        tgt_nid = _make_id(pkg)
+        add_node(tgt_nid, pkg, source_file=None)
+        add_edge(file_nid, tgt_nid, "imports", line=_line_at(m.start(1)))
+
+    for m in re.finditer(r"""^\s*export\s+['"]([^'"]+)['"]""", src_clean, re.MULTILINE):
+        pkg = m.group(1)
+        tgt_nid = _make_id(pkg)
+        add_node(tgt_nid, pkg, source_file=None)
+        add_edge(file_nid, tgt_nid, "exports", line=_line_at(m.start(1)))
+
+    # 7. Generic Invocations / Type Lookups (Universal Dependency Lookup)
+    # Matches any method call with type parameters: methodName<Type>() or object.methodName<Type>()
+    # Automatically extracts GetIt, Injectable, Riverpod, Provider, BlocProvider, and InheritedWidget type lookups!
+    generic_call_pattern = r"\b\w+<([a-zA-Z0-9_.]+(?:<[a-zA-Z0-9_.,\s<>]+>)?)\s*>\s*\("
+    type_blacklist = {"String", "int", "double", "bool", "num", "dynamic", "Object", "List", "Map", "Set", "Future", "Stream", "void"}
+    for m in re.finditer(generic_call_pattern, src_clean):
+        type_name = m.group(1).split(".")[-1].strip()
+        clean_name = type_name.split("<")[0].strip()
+        if clean_name not in type_blacklist:
+            target_nid = _make_id(clean_name)
+            add_node(target_nid, clean_name, source_file=None)
+            add_edge(file_nid, target_nid, "references", context="type_lookup",
+                      line=_line_at(m.start(1)))
+
+    return {"nodes": nodes, "edges": edges}