Feature Request: Add Hybrid LSP support for Julia

[zhuh2664-coder]

What problem does this solve?

I'm indexing Julia projects with codebase-memory-mcp. The tree-sitter layer
extracts functions/structs/modules fine, but cross-file call tracing is
broken because Julia uses multiple dispatch — method resolution depends on
argument types, not just function names.

Concrete example:

File A: src/models/user.jl

function process(data::DataFrame)
transform(data, :name => uppercase)
end

File B: src/api/handler.jl

function handle_request(req)
df = load_data(req)
process(df) # ← codebase-memory-mcp can't resolve this call
end

Without Hybrid LSP, the graph shows NO edge between handle_request and
process, because it can't infer that df is a DataFrame and therefore
process(::DataFrame) is the correct dispatch target.

Impact:

• Call graph is incomplete for any Julia project using type-based dispatch
  (which is ALL Julia projects)
• Dead code detection gives false positives (thinks dispatched methods are
  unused)
• trace_path returns empty for cross-module calls

---

Proposed solution

Add Hybrid LSP pass for Julia that resolves:

1. using/import chains to build module dependency graph
2. Type annotations and parametric types for method dispatch resolution
3. Multiple dispatch: match call sites to method signatures by argument types
4. Common patterns: @generated functions, macro expansions (basic level)

Suggested test repositories:

• Flux.jl (https://github.com/FluxML/Flux.jl) — ML framework, heavy use of
  dispatch and parametric types (~15k LOC)
• DifferentialEquations.jl
  (https://github.com/SciML/DifferentialEquations.jl) — scientific computing,
  complex module hierarchy
• Genie.jl (https://github.com/GenieFramework/Genie.jl) — web framework, HTTP
  routing patterns similar to Go/TS Hybrid LSP implementations
• Makie.jl (https://github.com/MakieOrg/Makie.jl) — visualization, large
  multi-package structure

Priority: Flux.jl is the best starting point — small enough to iterate fast,
complex enough to exercise dispatch, parametric types, and macros.

---

Alternatives considered

Type-stripped fallback resolution:
When Hybrid LSP can't resolve types, fall back to matching function calls
by NAME ONLY (ignoring all argument types). For a call like process(df),
find ALL process definitions in the project and create edges to ALL of
them with a "unresolved_dispatch" flag.

 Pros: Simple to implement, no type inference needed, zero false negatives
 for call existence (though may have false positives for dispatch target).
 Cons: Creates multiple edges per call site, may need post-filtering.

Confirmations

• I searched existing issues and this is not a duplicate.

[DeusData]

Hey, we are currently trying to build LSP Hybrids for other languages. If the community demands julia, we can prioritize it up. But for now it will likely not land in the close future, ss LSP Hybrid äs tend to be tricky requiri g a high parity test coverage etc. If you like you can attempt it yourself in a light version given the existing patterns and commit it as PR :) Would support you with it