Format files using DocumentFormat

Author: davidanthoff

docs/make.jl

@@ -7,16 +7,16 @@ makedocs(;
     repo="https://github.com/julia-vscode/SymbolServer.jl/blob/{commit}{path}#L{line}",
     sitename="SymbolServer.jl",
     format=Documenter.HTML(;
-        prettyurls=prettyurls = get(ENV, "CI", nothing) == "true",
+        prettyurls=prettyurls = get(ENV, "CI", nothing) == "true"
         # canonical="https://www.julia-vscode.org/SymbolServer.jl",
         # assets=String[],
     ),
     pages=[
         "Home" => "index.md",
         "Syntax Reference" => "syntax.md",
-    ],
+    ]
 )
 
 deploydocs(;
-    repo="github.com/julia-vscode/SymbolServer.jl",
+    repo="github.com/julia-vscode/SymbolServer.jl"
 )

registryindexer/main.jl

@@ -2,7 +2,7 @@
 
 max_n = 1_000_000
 max_versions = 1_000_000
-max_tasks = length(ARGS)>1 ? parse(Int, ARGS[2]) : 1
+max_tasks = length(ARGS) > 1 ? parse(Int, ARGS[2]) : 1
 
 julia_versions = [v"1.7.2"]
 
@@ -13,26 +13,26 @@ Pkg.instantiate()
 
 using ProgressMeter, Query, JSON, UUIDs, Tar, CodecZlib
 
-function get_all_package_versions(;max_versions=typemax(Int))
+function get_all_package_versions(; max_versions=typemax(Int))
     registry_folder_path = joinpath(homedir(), ".julia", "registries", "General")
     registry_path = joinpath(registry_folder_path, "Registry.toml")
 
     registry_content = Pkg.TOML.parsefile(registry_path)
 
     packages = registry_content["packages"] |>
-        @map({
-            name = _[2]["name"],
-            uuid = UUID(_[1]),
-            path = _[2]["path"]
-        }) |>
-        @mutate(
-            versions = (Pkg.TOML.parsefile(joinpath(registry_folder_path, _.path, "Versions.toml")) |>
-                @map(i->{version=VersionNumber(i[1]), treehash=i[2]["git-tree-sha1"]}) |> 
-                @orderby_descending(i->i.version) |>
-                @take(max_versions) |>
-                collect)
-        ) |>
-        collect
+               @map({
+                   name = _[2]["name"],
+                   uuid = UUID(_[1]),
+                   path = _[2]["path"]
+               }) |>
+               @mutate(
+                   versions = (Pkg.TOML.parsefile(joinpath(registry_folder_path, _.path, "Versions.toml")) |>
+                               @map(i -> {version = VersionNumber(i[1]), treehash = i[2]["git-tree-sha1"]}) |>
+                               @orderby_descending(i -> i.version) |>
+                               @take(max_versions) |>
+                               collect)
+               ) |>
+               collect
 
     return packages
 end
@@ -42,7 +42,7 @@ function get_flattened_package_versions(packages)
 
     for p in packages
         for v in p.versions
-            push!(flattened_packageversions, (;p.name, p.uuid, p.path, version=v.version, treehash=v.treehash))
+            push!(flattened_packageversions, (; p.name, p.uuid, p.path, version=v.version, treehash=v.treehash))
         end
     end
 
@@ -54,11 +54,11 @@ function execute(cmd::Base.Cmd)
     err = IOBuffer()
     process = run(pipeline(ignorestatus(cmd), stdout=out, stderr=err))
 
-    out_string =String(take!(out))
+    out_string = String(take!(out))
     err_string = String(take!(err))
-    return (stdout = out_string,
-            stderr = err_string,
-            code = process.exitcode)
+    return (stdout=out_string,
+        stderr=err_string,
+        code=process.exitcode)
 end
 
 @info "Indexing started..."
@@ -69,7 +69,7 @@ flattened_packageversions = get_flattened_package_versions(all_packages)
 
 @info "Loaded package versions from registry..."
 
-cache_folder = length(ARGS)>0 ? ARGS[1] : joinpath(@__DIR__, "..", "registryindexcache")
+cache_folder = length(ARGS) > 0 ? ARGS[1] : joinpath(@__DIR__, "..", "registryindexcache")
 
 @info "Using the following folder as the cache folder: " cache_folder
 
@@ -92,7 +92,7 @@ asyncmap(julia_versions) do v
         print(f, res.stderr)
     end
 
-    if res.code!=0
+    if res.code != 0
         error("Could not create docker image.")
     end
 end
@@ -108,10 +108,10 @@ true || asyncmap(julia_versions) do v
     else
         res = execute(`docker run --rm --mount type=bind,source="$cache_folder",target=/symcache juliavscodesymbolindexer:$v julia SymbolServer/src/indexbasestdlib.jl $v`)
 
-        if res.code==10 || res.code==20
-            if res.code==10
+        if res.code == 10 || res.code == 20
+            if res.code == 10
                 # global count_failed_to_load += 1
-            elseif res.code==20
+            elseif res.code == 20
                 # global count_failed_to_install += 1
             end
 
@@ -121,7 +121,7 @@ true || asyncmap(julia_versions) do v
             #     # Write them to a file
             #     open(joinpath(path, error_filename), "w") do io                    
             #     end
-            
+
             #     Pkg.PlatformEngines.package(path, cache_path)
             # end
 
@@ -136,7 +136,7 @@ true || asyncmap(julia_versions) do v
             # global status_db
 
             # push!(status_db, Dict("name"=>v.name, "uuid"=>string(v.uuid), "version"=>string(v.version), "treehash"=>v.treehash, "status"=>res.code==20 ? "install_error" : "load_error", "indexattempts"=>[Dict("juliaversion"=>string(VERSION), "stdout"=>res.stdout, "stderr"=>res.stderr)]))
-        elseif res.code==0
+        elseif res.code == 0
             # global count_successfully_cached += 1
         else
             # global count_failed_to_index += 1
@@ -154,7 +154,7 @@ end
 @info "Now computing which of the total $(length(flattened_packageversions)) package versions that exist still need to be indexed..."
 
 unindexed_packageversions = filter(collect(Iterators.take(flattened_packageversions, max_n))) do v
-    versionwithoutplus = replace(string(v.version), '+'=>'_')
+    versionwithoutplus = replace(string(v.version), '+' => '_')
 
     cache_path = joinpath(cache_folder, "v1", "packages", string(uppercase(v.name[1])), "$(v.name)_$(v.uuid)", "v$(versionwithoutplus)_$(v.treehash).tar.gz")
 
@@ -179,7 +179,7 @@ status_db = isfile(statusdb_filename) ? JSON.parsefile(statusdb_filename) : []
 @info "Starting the actual indexing process..."
 
 asyncmap(unindexed_packageversions, ntasks=max_tasks) do v
-    versionwithoutplus = replace(string(v.version), '+'=>'_')
+    versionwithoutplus = replace(string(v.version), '+' => '_')
 
     cache_path = joinpath(cache_folder, "v1", "packages", string(uppercase(v.name[1])), "$(v.name)_$(v.uuid)")
     mkpath(cache_path)
@@ -188,12 +188,12 @@ asyncmap(unindexed_packageversions, ntasks=max_tasks) do v
     mktempdir() do path
         res = execute(`docker run --rm --mount type=bind,source="$path",target=/symcache juliavscodesymbolindexer:$(first(julia_versions)) julia SymbolServer/src/indexpackage.jl $(v.name) $(v.version) $(v.uuid) $(v.treehash)`)
 
-        if res.code==37 # This is our magic error code that indicates everything worked
+        if res.code == 37 # This is our magic error code that indicates everything worked
             global count_successfully_cached += 1
         else
-            if res.code==10
+            if res.code == 10
                 global count_failed_to_load += 1
-            elseif res.code==20
+            elseif res.code == 20
                 global count_failed_to_install += 1
             else
                 global count_failed_to_index += 1
@@ -209,20 +209,20 @@ asyncmap(unindexed_packageversions, ntasks=max_tasks) do v
             isfile(joinpath(path, error_filename)) && rm(joinpath(path, error_filename))
 
             # Write them to a file
-            open(joinpath(path, error_filename), "w") do io                    
+            open(joinpath(path, error_filename), "w") do io
             end
 
-            open(joinpath(cache_folder, "logs", res.code==10 ? "packageloadfailure" : res.code==20 ? "packageinstallfailure" : "packageindexfailure", "log_$(v.name)_v$(versionwithoutplus)_stdout.txt"), "w") do f
+            open(joinpath(cache_folder, "logs", res.code == 10 ? "packageloadfailure" : res.code == 20 ? "packageinstallfailure" : "packageindexfailure", "log_$(v.name)_v$(versionwithoutplus)_stdout.txt"), "w") do f
                 print(f, res.stdout)
             end
 
-            open(joinpath(cache_folder, "logs", res.code==10 ? "packageloadfailure" : res.code==20 ? "packageinstallfailure" : "packageindexfailure", "log_$(v.name)_v$(versionwithoutplus)_stderr.txt"), "w") do f
+            open(joinpath(cache_folder, "logs", res.code == 10 ? "packageloadfailure" : res.code == 20 ? "packageinstallfailure" : "packageindexfailure", "log_$(v.name)_v$(versionwithoutplus)_stderr.txt"), "w") do f
                 print(f, res.stderr)
             end
 
             global status_db
 
-            push!(status_db, Dict("name"=>v.name, "uuid"=>string(v.uuid), "version"=>string(v.version), "treehash"=>v.treehash, "status"=>res.code==20 ? "install_error" : res.code==10 ? "load_error" : "index_error", "indexattempts"=>[Dict("juliaversion"=>string(VERSION), "stdout"=>res.stdout, "stderr"=>res.stderr)]))
+            push!(status_db, Dict("name" => v.name, "uuid" => string(v.uuid), "version" => string(v.version), "treehash" => v.treehash, "status" => res.code == 20 ? "install_error" : res.code == 10 ? "load_error" : "index_error", "indexattempts" => [Dict("juliaversion" => string(VERSION), "stdout" => res.stdout, "stderr" => res.stderr)]))
         end
 
         # @info "Files to be compressed" path readdir(path, join=true) ispath(cache_path) isfile(cache_path_compressed)
@@ -237,8 +237,8 @@ asyncmap(unindexed_packageversions, ntasks=max_tasks) do v
         end
     end
 
-    next!(p, showvalues = [
-        (:finished_package_count,p.counter+1),
+    next!(p, showvalues=[
+        (:finished_package_count, p.counter + 1),
         (:count_successfully_cached, count_successfully_cached),
         (:count_failed_to_install, count_failed_to_install),
         (:count_failed_to_load, count_failed_to_load),

src/SymbolServer.jl

@@ -19,15 +19,15 @@ mutable struct SymbolServerInstance
     store_path::String
     symbolcache_upstream::String
 
-    function SymbolServerInstance(depot_path::String="", store_path::Union{String,Nothing}=nothing; symbolcache_upstream = nothing)
+    function SymbolServerInstance(depot_path::String="", store_path::Union{String,Nothing}=nothing; symbolcache_upstream=nothing)
         if symbolcache_upstream === nothing
             symbolcache_upstream = "https://www.julia-vscode.org/symbolcache"
         end
         return new(nothing, depot_path, Set{Process}(), store_path === nothing ? abspath(joinpath(@__DIR__, "..", "store")) : store_path, symbolcache_upstream)
     end
 end
 
-function getstore(ssi::SymbolServerInstance, environment_path::AbstractString, progress_callback=nothing, error_handler=nothing; download = false)
+function getstore(ssi::SymbolServerInstance, environment_path::AbstractString, progress_callback=nothing, error_handler=nothing; download=false)
     !ispath(environment_path) && return :success, recursive_copy(stdlibs)
 
     # see if we can download any package cache's before
@@ -42,9 +42,9 @@ function getstore(ssi::SymbolServerInstance, environment_path::AbstractString, p
                     if manifest !== nothing
                         @debug "Downloading cache files for manifest at $(manifest_filename)."
                         to_download = collect(validate_disc_store(ssi.store_path, manifest))
-                        batches = Iterators.partition(to_download, max(1, floor(Int, length(to_download)÷50)))
+                        batches = Iterators.partition(to_download, max(1, floor(Int, length(to_download) ÷ 50)))
                         for (i, batch) in enumerate(batches)
-                            percentage = round(Int, 100*(i - 1)/length(batches))
+                            percentage = round(Int, 100 * (i - 1) / length(batches))
                             progress_callback !== nothing && progress_callback("Downloading caches...", percentage)
                             @sync for pkg in batch
                                 @async begin
@@ -131,7 +131,7 @@ function getstore(ssi::SymbolServerInstance, environment_path::AbstractString, p
         end
     end
     take!(server_is_ready)
-    p = open(pipeline(Cmd(`$jl_cmd --code-coverage=$(use_code_coverage==0 ? "none" : "user") --startup-file=no --compiled-modules=no --history-file=no --project=$environment_path $server_script $(ssi.store_path) $pipename`, env=env_to_use),  stderr=stderr_for_client_process), read=true, write=true)
+    p = open(pipeline(Cmd(`$jl_cmd --code-coverage=$(use_code_coverage==0 ? "none" : "user") --startup-file=no --compiled-modules=no --history-file=no --project=$environment_path $server_script $(ssi.store_path) $pipename`, env=env_to_use), stderr=stderr_for_client_process), read=true, write=true)
     ssi.process = p
 
     yield()
@@ -150,7 +150,7 @@ function getstore(ssi::SymbolServerInstance, environment_path::AbstractString, p
     else
         @debug "SymbolStore: store failure"
         if currently_loading_a_package
-            return :package_load_crash, (package_name = current_package_name, stderr = stderr_for_client_process)
+            return :package_load_crash, (package_name=current_package_name, stderr=stderr_for_client_process)
         else
             return :failure, stderr_for_client_process
         end
@@ -171,15 +171,16 @@ function pipe_name()
         # Try to use /tmp and if that fails, hope the long pipe name works anyway
         maybe = "/tmp/" * prefix * uuid
         try
-            touch(maybe); rm(maybe) # Check permissions on this path
+            touch(maybe)
+            rm(maybe) # Check permissions on this path
             pipename = maybe
         catch
         end
     end
     return pipename
 end
 
-function load_project_packages_into_store!(ssi::SymbolServerInstance, environment_path, store, progress_callback = nothing)
+function load_project_packages_into_store!(ssi::SymbolServerInstance, environment_path, store, progress_callback=nothing)
     project_filename = isfile(joinpath(environment_path, "JuliaProject.toml")) ? joinpath(environment_path, "JuliaProject.toml") : joinpath(environment_path, "Project.toml")
     project = try
         Pkg.API.read_project(project_filename)
@@ -203,7 +204,7 @@ end
 
 Tries to load the on-disc stored cache for a package (uuid). Attempts to generate (and save to disc) a new cache if the file does not exist or is unopenable.
 """
-function load_package_from_cache_into_store!(ssi::SymbolServerInstance, uuid::UUID, environment_path, manifest, store, progress_callback = nothing, percentage = missing)
+function load_package_from_cache_into_store!(ssi::SymbolServerInstance, uuid::UUID, environment_path, manifest, store, progress_callback=nothing, percentage=missing)
     yield()
     isinmanifest(manifest, uuid) || return
     pe = frommanifest(manifest, uuid)
@@ -252,7 +253,7 @@ end
 function clear_disc_store(ssi::SymbolServerInstance)
     for f in readdir(ssi.store_path)
         if occursin(f, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-            rm(joinpath(ssi.store_path, f), recursive = true)
+            rm(joinpath(ssi.store_path, f), recursive=true)
         end
     end
 end

src/faketypes.jl

@@ -88,7 +88,7 @@ function Base.print(io::IO, tn::FakeTypeName)
 end
 Base.print(io::IO, x::FakeUnionAll) = print(io, x.body, " where ", x.var)
 function Base.print(io::IO, x::FakeUnion; inunion=false)
-    !inunion && print(io,  "Union{")
+    !inunion && print(io, "Union{")
     print(io, x.a, ",")
     if x.b isa FakeUnion
         print(io, x.b, inunion=true)

src/indexpackage.jl

@@ -13,7 +13,7 @@ current_package_treehash = ARGS[4]
 # This path will always be mounted in the docker container in which we are running
 store_path = "/symcache"
 
-current_package_versionwithoutplus = replace(string(current_package_version), '+'=>'_')
+current_package_versionwithoutplus = replace(string(current_package_version), '+' => '_')
 filename_with_extension = "v$(current_package_versionwithoutplus)_$current_package_treehash.jstore"
 
 module LoadingBay end
@@ -45,7 +45,7 @@ end
 env = getenvtree([current_package_name])
 symbols(env, m, get_return_type=true)
 
- # Strip out paths
+# Strip out paths
 modify_dirs(env[current_package_name], f -> modify_dir(f, pkg_src_dir(Base.loaded_modules[Base.PkgId(current_package_uuid, string(current_package_name))]), "PLACEHOLDER"))
 
 # There's an issue here - @enum used within CSTParser seems to add a method that is introduced from Enums.jl...

src/serialize.jl

@@ -169,7 +169,7 @@ function write_vector(io, x)
     end
 end
 
-function read(io, t = Base.read(io, UInt8))
+function read(io, t=Base.read(io, UInt8))
     # There are a bunch of `yield`s in potentially expensive code paths.
     # One top-level `yield` would probably increase responsiveness in the
     # LS, but increases runtime by 3x. This seems like a good compromise.
@@ -221,7 +221,7 @@ function read(io, t = Base.read(io, UInt8))
         file = read(io)
         line = Base.read(io, UInt32)
         nsig = Base.read(io, Int)
-        sig = Vector{Pair{Any, Any}}(undef, nsig)
+        sig = Vector{Pair{Any,Any}}(undef, nsig)
         for i in 1:nsig
             sig[i] = read(io) => read(io)
         end
@@ -259,7 +259,7 @@ function read(io, t = Base.read(io, UInt8))
         false
     elseif t === TupleHeader
         N = Base.read(io, Int)
-        ntuple(i->read(io), N)
+        ntuple(i -> read(io), N)
     elseif t === PackageHeader
         yield()
         name = read(io)

src/server.jl

@@ -92,7 +92,7 @@ visited = Base.IdSet{Module}([Base, Core])
 
 # Load all packages together
 for (i, uuid) in enumerate(packages_to_load)
-    load_package(ctx, uuid, conn, LoadingBay, round(Int, 100*(i - 1)/length(packages_to_load)))
+    load_package(ctx, uuid, conn, LoadingBay, round(Int, 100 * (i - 1) / length(packages_to_load)))
 
     # XXX: The following *may* duplicate some work, but we want to make sure that interrupts of
     #      the SymbolServer process don't invalidate *all* work done (which would happen when only
@@ -103,12 +103,12 @@ for (i, uuid) in enumerate(packages_to_load)
 
     # Populate the above with symbols, skipping modules that don't need caching.
     # symbols (env_symbols)
-     # don't need to cache these each time...
+    # don't need to cache these each time...
     for (pid, m) in Base.loaded_modules
         if pid.uuid !== nothing &&
-                is_stdlib(pid.uuid) &&
-                isinmanifest(ctx, pid.uuid) &&
-                isfile(joinpath(server.storedir, SymbolServer.get_cache_path(manifest(ctx), pid.uuid)...))
+           is_stdlib(pid.uuid) &&
+           isinmanifest(ctx, pid.uuid) &&
+           isfile(joinpath(server.storedir, SymbolServer.get_cache_path(manifest(ctx), pid.uuid)...))
             push!(visited, m)
             delete!(env_symbols, Symbol(pid.name))
         end