Merge branch 'master' into releases/2025-11-30

Author: aviatesk

CHANGELOG.md

@@ -18,11 +18,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 
-- JETLS now automatically runs `Pkg.instantiate()` for packages that have not
-  been instantiated yet (e.g., freshly cloned repositories). This allows
-  full analysis to work immediately upon opening such packages. Note that this
-  will automatically create a `Manifest.toml` file when the package has not been
-  instantiated yet. This behavior is controlled by the `full_analysis.auto_instantiate`
+- JETLS now automatically runs `Pkg.resolve()` and `Pkg.instantiate()` for
+  packages that have not been instantiated yet (e.g., freshly cloned repositories).
+  This allows full analysis to work immediately upon opening such packages.
+  When no manifest file exists, JETLS first creates a
+  [versioned manifest](https://pkgdocs.julialang.org/v1/toml-files/#Different-Manifests-for-Different-Julia-versions)
+  (e.g., `Manifest-v1.12.toml`).
+  This behavior is controlled by the `full_analysis.auto_instantiate`
   configuration option (default: `true`). Set it to `false` to disable.
 - When `full_analysis.auto_instantiate` is disabled, JETLS now checks if the
   environment is instantiated and warns the user if not.
@@ -36,6 +38,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   opened simultaneously. Added global lock to `activate_do` to serialize
   environment switching operations. This fixes spurious "Failed to identify
   package environment" warnings.
+- Fixed document highlight and rename not working for function parameters
+  annotated with `@nospecialize` or `@specialize`.
 
 ### Internal
 

docs/src/configuration.md

@@ -65,11 +65,12 @@ debounce = 2.0  # Wait 2 seconds after save before analyzing
 - **Type**: boolean
 - **Default**: `true`
 
-When enabled, JETLS automatically runs `Pkg.instantiate()` for packages that have
-not been instantiated yet (e.g., freshly cloned repositories). This allows full
-analysis to work immediately upon opening such packages. Note that this will
-automatically create a `Manifest.toml` file when the package has not been
-instantiated yet.
+When enabled, JETLS automatically runs `Pkg.resolve()` and `Pkg.instantiate()` for
+packages that have not been instantiated yet (e.g., freshly cloned repositories).
+This allows full analysis to work immediately upon opening such packages.
+When no manifest file exists, JETLS first creates a
+[versioned manifest](https://pkgdocs.julialang.org/v1/toml-files/#Different-Manifests-for-Different-Julia-versions)
+(e.g., `Manifest-v1.12.toml`).
 
 ```toml
 [full_analysis]

src/analysis/full-analysis.jl

@@ -676,6 +676,14 @@ end
 function ensure_instantiated!(server::Server, env_path::String)
     if get_config(server.state.config_manager, :full_analysis, :auto_instantiate)
         try
+            manifest_name = "Manifest-v$(VERSION.major).$(VERSION.minor).toml"
+            manifest_path = joinpath(dirname(env_path), manifest_name)
+            if !isfile(manifest_path)
+                JETLS_DEV_MODE && @info "Touching versioned manifest file" env_path
+                touch(manifest_path)
+            end
+            JETLS_DEV_MODE && @info "Resolving package environment" env_path
+            Pkg.resolve()
             JETLS_DEV_MODE && @info "Instantiating package environment" env_path
             Pkg.instantiate()
         catch e

src/utils/ast.jl

@@ -31,8 +31,30 @@ function without_kinds(st::JL.SyntaxTree, kinds::Tuple{Vararg{JS.Kind}})
         _without_kinds(st, kinds)[1])::JL.SyntaxTree
 end
 
+function is_nospecialize_or_specialize_macrocall(st::JL.SyntaxTree)
+    JS.kind(st) === JS.K"macrocall" || return false
+    JS.numchildren(st) >= 1 || return false
+    macro_name_node = st[1]
+    JS.kind(macro_name_node) === JS.K"macro_name" || return false
+    JS.numchildren(macro_name_node) >= 1 || return false
+    macro_name = macro_name_node[1]
+    JS.kind(macro_name) === JS.K"Identifier" || return false
+    hasproperty(macro_name, :name_val) || return false
+    return macro_name.name_val == "nospecialize" || macro_name.name_val == "specialize"
+end
+
 function _remove_macrocalls(st::JL.SyntaxTree)
     if JS.kind(st) === JS.K"macrocall"
+        if is_nospecialize_or_specialize_macrocall(st)
+            # Special case `@nospecialize`/`@specialize`:
+            # These macros are sometimes used in method definition argument lists, but
+            # if we apply the `_remove_macrocalls` transformation directly, it would
+            # result in a `:block` expression being inserted into the argument list,
+            # preventing generation of a correct lowered tree.
+            # Furthermore, JuliaLowering.jl provides new macro style definitions for
+            # these macros, so there's no need to remove them in the first place.
+            return st, false
+        end
         new_children = JL.SyntaxList(JL.syntax_graph(st))
         for i = 2:JS.numchildren(st)
             push!(new_children, _remove_macrocalls(st[i])[1])

test/test_document_highlight.jl

@@ -119,6 +119,33 @@ end
             end
         end
 
+        @testset "highlight with @nospecialize" begin
+            code = """
+            function func(@nospecialize(│xxx│), yyy)
+                zzz = │xxx│, yyy
+                zzz, yyy
+            end
+            """
+            clean_code, positions = JETLS.get_text_and_positions(code)
+            @test length(positions) == 4
+            fi = JETLS.FileInfo(#=version=#0, clean_code, @__FILE__)
+            @test issorted(positions; by = x -> JETLS.xy_to_offset(fi, x))
+            for pos in positions
+                highlights = JETLS.document_highlights(fi, pos)
+                @test length(highlights) == 2
+                @test any(highlights) do highlight
+                    highlight.range.start == positions[1] &&
+                    highlight.range.var"end" == positions[2] &&
+                    highlight.kind == DocumentHighlightKind.Write
+                end
+                @test any(highlights) do highlight
+                    highlight.range.start == positions[3] &&
+                    highlight.range.var"end" == positions[4] &&
+                    highlight.kind == DocumentHighlightKind.Read
+                end
+            end
+        end
+
         let code = """
             let │xxx│, │yyy│ = :yyy
                 │xxx│ = :xxx