[JuliaLowering] Provenance problem with old-style macros

[singularitti]

When JETLS detects an unused local binding, it renders the affected code with curly underlines. This generally behaves correctly in ordinary local scopes (e.g. inside a function body). However, when the unused binding appears inside a macro expansion, the language server applies the underline styling to the entire macro application range, rather than to the specific binding.

This results in excessive visual noise in VS Code: every line in the macro application is underlined and dimmed, even though only a single local binding is unused.

Minimal Working Example

using RecipesBase: @recipe

@recipe function a(x)
    b = 1
    return nothing
end

Here, b is unused, which is correct to flag. However, in VS Code the entire macro application range (@recipe function ... end) is rendered with curly underlines and reduced opacity, rather than pinpointing just the line defining b.

Expected Behavior

Only the exact source range corresponding to the unused local binding (b = 1) should be underlined and styled.

Actual Behavior

The full macro application range is underlined and dimmed, making the diagnostic overly broad and visually distracting.

Question / Suggestion

Is it possible for JETLS to:

• Track the precise source location of the unused binding inside a macro expansion, and
• Restrict the diagnostic range to that specific binding (or at least the relevant line), instead of the entire macro invocation?

[singularitti]

Version: 1.108.1
Commit: 585eba7c0c34fd6b30faac7c62a42050bfbc0086
Date: 2026-01-14T14:55:44.241Z
Electron: 39.2.7
ElectronBuildId: 12953945
Chromium: 142.0.7444.235
Node.js: 22.21.1
V8: 14.2.231.21-electron.0
OS: Darwin arm64 25.2.0

In [0]: versioninfo()
Julia Version 1.13.0-beta1
Commit b6610e890b3 (2026-01-12 13:00 UTC)
Build Info:
  Official https://julialang.org release
Platform Info:
  OS: macOS (arm64-apple-darwin24.0.0)
  CPU: 14 × Apple M4 Pro
  WORD_SIZE: 64
  LLVM: libLLVM-20.1.8 (ORCJIT, apple-m4)
  GC: Built with stock GC
Threads: 10 default, 1 interactive, 10 GC (on 10 virtual cores)

(@v1.13) pkg> app st
[a3b70258] JETLS v0.0.0 `https://github.com/aviatesk/JETLS.jl#2026-01-17`
  jetls ~/.julia/juliaup/julia-1.13.0-beta1+0.aarch64.apple.darwin14/bin/julia

[aviatesk]

This is a known limitation of JuliaLowering.
@mlechu Have we already come up with any ideas for solving this limitation? I wonder if this be improved by the est_to_dst work.

[mlechu]

Will need to be worked on in the future, either by adding stuff to Expr or making "new" macros available to users. The limitation is that @recipe is a function Expr->Expr, so precise provenance is removed when we call it.

[aviatesk]

Yea we can wait for the new style macro system to be polished and adopted, but that would take a significant amount of time I guess..

It might be worth "Adding stuff to Expr" so that we can preserve precise location information for "simple" Expr->Expr case?
For example, in cases where we simply embed an expression into the output, like the following, it would be nice to be able to use the original precise provenance of the embedded tree:

julia> macro usevar(var)
           :(let v = $(esc(var))
               println(v)
               v
           end)
       end;

julia> jldebug("""let x = 42
           @usevar x
       end
       """);

julia> st1[2][1]
SyntaxTree with attributes scope_layer,kind,value,var_id,name_val,syntax_flags,meta,source
[let]                                                        │ 
  [block]                                                    │ 
    [=]                                                      │ 
      v                                  :: Identifier       │ scope_layer=2
      x                                  :: Identifier       │ scope_layer=1
  [block]                                                    │ 
    [call]                                                   │ 
      println                            :: Identifier       │ scope_layer=2
      v                                  :: Identifier       │ scope_layer=2
    v                                    :: Identifier       │ scope_layer=2


julia> JL.showprov(st1[2][1][1][1][2])
#= /Users/aviatesk/julia/julia/jsjl-utils.jl:2 =# - in source
# @ /Users/aviatesk/julia/julia/jsjl-utils.jl:2

let x = 42
    @usevar x
#   └───────┘ ── in macro expansion
end
# @ /Users/aviatesk/julia/julia/jsjl-utils.jl:2

I guess it's actually quite difficult to determine whether "an expression is simply embedded into the output" in practice... Still, if provenance is widened across the entire macro tree as above, it certainly does make unused diagnostics harder to understand.