Backports for 1.12 (#4388)

Author: KristofferC

.github/workflows/test.yml

@@ -102,3 +102,9 @@ jobs:
           julia --project=docs --color=yes docs/make.jl pdf
         env:
           DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
+      - name: Upload documentation artifacts
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: pkg-docs
+          path: docs/build/

docs/src/apps.md

@@ -42,7 +42,7 @@ end # module
 [apps]
 reverse = {}
 ```
-The empty table `{}` is to allow for giving metadata about the app but it is currently unused.
+The empty table `{}` is to allow for giving metadata about the app.
 
 After installing this app one could run:
 
@@ -95,6 +95,66 @@ This will create two executables:
 - `main-app` that runs `julia -m MyMultiApp`
 - `cli-app` that runs `julia -m MyMultiApp.CLI`
 
+## Configuring Julia Flags
+
+Apps can specify default Julia command-line flags that will be passed to the Julia process when the app is run. This is useful for configuring performance settings, threading, or other Julia options specific to your application.
+
+### Default Julia Flags
+
+You can specify default Julia flags in the `Project.toml` file using the `julia_flags` field:
+
+```toml
+# Project.toml
+
+[apps]
+myapp = { julia_flags = ["--threads=4", "--optimize=2"] }
+performance-app = { julia_flags = ["--threads=auto", "--startup-file=yes", "--depwarn=no"] }
+debug-app = { submodule = "Debug", julia_flags = ["--check-bounds=yes", "--optimize=0"] }
+```
+
+With this configuration:
+- `myapp` will run with 4 threads and optimization level 2
+- `performance-app` will run with automatic thread detection, startup file enabled, and deprecation warnings disabled
+- `debug-app` will run with bounds checking enabled and no optimization
+
+### Runtime Julia Flags
+
+You can override or add to the default Julia flags at runtime using the `--` separator. Everything before `--` will be passed as flags to Julia, and everything after `--` will be passed as arguments to your app:
+
+```bash
+# Uses default flags from Project.toml
+myapp input.txt output.txt
+
+# Override thread count, keep other defaults
+myapp --threads=8 -- input.txt output.txt
+
+# Add additional flags
+myapp --threads=2 --optimize=3 --check-bounds=yes -- input.txt output.txt
+
+# Only Julia flags, no app arguments
+myapp --threads=1 --
+```
+
+The final Julia command will combine:
+1. Fixed flags (like `--startup-file=no` and `-m ModuleName`)
+2. Default flags from `julia_flags` in Project.toml
+3. Runtime flags specified before `--`
+4. App arguments specified after `--`
+
+### Overriding the Julia Executable
+
+By default, apps run with the same Julia executable that was used to install them. You can override this globally using the `JULIA_APPS_JULIA_CMD` environment variable:
+
+```bash
+# Use a different Julia version for all apps
+export JULIA_APPS_JULIA_CMD=/path/to/different/julia
+myapp input.txt
+
+# On Windows
+set JULIA_APPS_JULIA_CMD=C:\path\to\different\julia.exe
+myapp input.txt
+```
+
 ## Installing Julia apps
 
 The installation of Julia apps is similar to [installing Julia libraries](@ref Managing-Packages) but instead of using e.g. `Pkg.add` or `pkg> add` one uses `Pkg.Apps.add` or `pkg> app add` (`develop` is also available).

docs/src/index.md

@@ -4,6 +4,23 @@ Welcome to the documentation for Pkg, [Julia](https://julialang.org)'s package m
 The documentation covers many things, for example managing package
 installations, developing packages, working with package registries and more.
 
+```@eval
+import Markdown
+# For Pkg, we need to determine the appropriate Julia version for the PDF
+# Since Pkg docs are versioned by Julia version, we'll use a similar approach to Julia docs
+julia_patch = if VERSION.prerelease == ()
+    "v$(VERSION.major).$(VERSION.minor).$(VERSION.patch)"
+elseif VERSION.prerelease[1] == "DEV"
+    "dev"
+end
+file = "Pkg.jl.pdf"
+url = "https://raw.githubusercontent.com/JuliaLang/Pkg.jl/gh-pages-pdf/$(julia_patch)/$(file)"
+Markdown.parse("""
+!!! note
+    The documentation is also available in PDF format: [$file]($url).
+""")
+```
+
 Throughout the manual the REPL interface to Pkg, the Pkg REPL mode, is used in the examples.
 There is also a functional API, which is preferred when not working
 interactively. This API is documented in the [API Reference](@ref) section.

ext/REPLExt/REPLExt.jl

@@ -273,7 +273,7 @@ function try_prompt_pkg_add(pkgs::Vector{Symbol})
             push!(keybindings, only("$n"))
             push!(shown_envs, expanded_env)
         end
-        menu = TerminalMenus.RadioMenu(option_list, keybindings=keybindings, pagesize=length(option_list))
+        menu = TerminalMenus.RadioMenu(option_list; keybindings = keybindings, pagesize = length(option_list))
         default = something(
             # select the first non-default env by default, if possible
             findfirst(!=(Base.active_project()), shown_envs),

ext/REPLExt/compat.jl

@@ -14,7 +14,7 @@ function compat(ctx::Context; io = nothing)
         push!(opt_strs, Operations.compat_line(io, dep, uuid, compat_str, longest_dep_len, indent = ""))
         push!(opt_pkgs, dep)
     end
-    menu = TerminalMenus.RadioMenu(opt_strs, pagesize=length(opt_strs))
+    menu = TerminalMenus.RadioMenu(opt_strs; pagesize = length(opt_strs))
     choice = try
         TerminalMenus.request("  Select an entry to edit:", menu)
     catch err

src/Apps/Apps.jl

@@ -441,7 +441,7 @@ end
 #########
 
 const SHIM_COMMENT = Sys.iswindows() ? "REM " : "#"
-const SHIM_VERSION = 1.0
+const SHIM_VERSION = 1.1
 const SHIM_HEADER = """$SHIM_COMMENT This file is generated by the Julia package manager.
                        $SHIM_COMMENT Shim version: $SHIM_VERSION"""
 
@@ -457,18 +457,18 @@ function generate_shim(pkgname, app::AppInfo, env, julia)
     validate_submodule_name(app.submodule)
 
     module_spec = app.submodule === nothing ? pkgname : "$(pkgname).$(app.submodule)"
-    
+
     filename = app.name * (Sys.iswindows() ? ".bat" : "")
     julia_bin_filename = joinpath(julia_bin_path(), filename)
     mkpath(dirname(julia_bin_filename))
     content = if Sys.iswindows()
         julia_escaped = "\"$(Base.shell_escape_wincmd(julia))\""
         module_spec_escaped = "\"$(Base.shell_escape_wincmd(module_spec))\""
-        windows_shim(julia_escaped, module_spec_escaped, env)
+        windows_shim(julia_escaped, module_spec_escaped, env, app.julia_flags)
     else
         julia_escaped = Base.shell_escape(julia)
         module_spec_escaped = Base.shell_escape(module_spec)
-        shell_shim(julia_escaped, module_spec_escaped, env)
+        shell_shim(julia_escaped, module_spec_escaped, env, app.julia_flags)
     end
     overwrite_file_if_different(julia_bin_filename, content)
     if Sys.isunix()
@@ -477,36 +477,134 @@ function generate_shim(pkgname, app::AppInfo, env, julia)
 end
 
 
-function shell_shim(julia_escaped::String, module_spec_escaped::String, env)
+function shell_shim(julia_escaped::String, module_spec_escaped::String, env, julia_flags::Vector{String})
+    julia_flags_escaped = join(Base.shell_escape.(julia_flags), " ")
+    julia_flags_part = isempty(julia_flags) ? "" : " $julia_flags_escaped"
+
+    load_path_escaped = Base.shell_escape(env)
+    depot_path_escaped = Base.shell_escape(join(DEPOT_PATH, ':'))
+
     return """
-        #!/bin/sh
+    #!/bin/sh
+    set -eu
 
         $SHIM_HEADER
 
-        export JULIA_LOAD_PATH=$(repr(env))
-        export JULIA_DEPOT_PATH=$(repr(join(DEPOT_PATH, ':')))
-        exec $julia_escaped \\
-            --startup-file=no \\
-            -m $module_spec_escaped \\
-            "\$@"
-        """
+    # Pin Julia paths for the child process
+    export JULIA_LOAD_PATH=$load_path_escaped
+    export JULIA_DEPOT_PATH=$depot_path_escaped
+
+    # Allow overriding Julia executable via environment variable
+    if [ -n "\${JULIA_APPS_JULIA_CMD:-}" ]; then
+        julia_cmd="\$JULIA_APPS_JULIA_CMD"
+    else
+        julia_cmd=$julia_escaped
+    fi
+
+    # If a `--` appears, args before it go to Julia, after it to the app.
+    # If no `--` appears, all original args go to the app (no Julia args).
+    found_separator=false
+    for a in "\$@"; do
+        [ "\$a" = "--" ] && { found_separator=true; break; }
+    done
+
+    if [ "\$found_separator" = "true" ]; then
+        # Build julia_args until `--`, then leave the rest in "\$@"
+        julia_args=""
+        while [ "\$#" -gt 0 ]; do
+            case "\$1" in
+            --) shift; break ;;
+            *)  julia_args="\$julia_args\${julia_args:+ }\$1"; shift ;;
+            esac
+        done
+        # Here: "\$@" are the app args after the separator
+        exec "\$julia_cmd" --startup-file=no$julia_flags_part \$julia_args -m $module_spec_escaped "\$@"
+    else
+        # No separator: all original args go straight to the app
+        exec "\$julia_cmd" --startup-file=no$julia_flags_part -m $module_spec_escaped "\$@"
+    fi
+    """
 end
 
-function windows_shim(julia_escaped::String, module_spec_escaped::String, env)
+function windows_shim(
+        julia_escaped::String,
+        module_spec_escaped::String,
+        env,
+        julia_flags::Vector{String},
+    )
+    flags_escaped = join(Base.shell_escape_wincmd.(julia_flags), " ")
+    flags_part = isempty(julia_flags) ? "" : " $flags_escaped"
+
+    depot_path = join(DEPOT_PATH, ';')
+
     return """
-        @echo off
+    @echo off
+    setlocal EnableExtensions DisableDelayedExpansion
 
         $SHIM_HEADER
 
-        setlocal
-        set JULIA_LOAD_PATH=$env
-        set JULIA_DEPOT_PATH=$(join(DEPOT_PATH, ';'))
-
-        $julia_escaped ^
-            --startup-file=no ^
+    rem --- Environment (no delayed expansion here to keep '!' literal) ---
+    set "JULIA_LOAD_PATH=$env"
+    set "JULIA_DEPOT_PATH=$depot_path"
+
+    rem --- Allow overriding Julia executable via environment variable ---
+    if defined JULIA_APPS_JULIA_CMD (
+        set "julia_cmd=%JULIA_APPS_JULIA_CMD%"
+    ) else (
+        set "julia_cmd=$julia_escaped"
+    )
+
+    rem --- Now enable delayed expansion for string building below ---
+    setlocal EnableDelayedExpansion
+
+    rem Parse arguments, splitting on first -- into julia_args / app_args
+    set "found_sep="
+    set "julia_args="
+    set "app_args="
+
+    :__next
+    if "%~1"=="" goto __done
+
+    if not defined found_sep if "%~1"=="--" (
+        set "found_sep=1"
+        shift
+        goto __next
+    )
+
+    if not defined found_sep (
+        if defined julia_args (
+            set "julia_args=!julia_args! %1"
+        ) else (
+            set "julia_args=%1"
+        )
+        shift
+        goto __next
+    )
+
+    if defined found_sep (
+        if defined app_args (
+            set "app_args=!app_args! %1"
+        ) else (
+            set "app_args=%1"
+        )
+        shift
+        goto __next
+    )
+
+    :__done
+    rem If no --, pass all original args to the app; otherwise use split vars
+    if defined found_sep (
+        "%julia_cmd%" ^
+            --startup-file=no$flags_part !julia_args! ^
+            -m $module_spec_escaped ^
+            !app_args!
+    ) else (
+        "%julia_cmd%" ^
+            --startup-file=no$flags_part ^
             -m $module_spec_escaped ^
             %*
-        """
+    )
+    """
 end
 
 end

src/Operations.jl

@@ -2684,7 +2684,11 @@ function print_status(env::EnvCache, old_env::Union{Nothing,EnvCache}, registrie
     end
     no_changes = all(p-> p[2] == p[3], xs)
     if no_changes
-        printpkgstyle(io, Symbol("No packages added to or removed from"), "$(pathrepr(manifest ? env.manifest_file : env.project_file))", ignore_indent)
+        if manifest
+            printpkgstyle(io, :Manifest, "No packages added to or removed from $(pathrepr(env.manifest_file))", ignore_indent; color = Base.info_color())
+        else
+            printpkgstyle(io, :Project, "No packages added to or removed from $(pathrepr(env.project_file))", ignore_indent; color = Base.info_color())
+        end
     else
         xs = !filter ? xs : eltype(xs)[(id, old, new) for (id, old, new) in xs if (id in uuids || something(new, old).name in names)]
         if isempty(xs)

src/Types.jl

@@ -242,7 +242,8 @@ struct AppInfo
     name::String
     julia_command::Union{String, Nothing}
     submodule::Union{String, Nothing}
-    other::Dict{String,Any}
+    julia_flags::Vector{String}
+    other::Dict{String, Any}
 end
 Base.@kwdef mutable struct Project
     other::Dict{String,Any} = Dict{String,Any}()

src/manifest.jl

@@ -87,10 +87,19 @@ function read_apps(apps::Dict)
     appinfos = Dict{String, AppInfo}()
     for (appname, app) in apps
         submodule = get(app, "submodule", nothing)
-        appinfo = AppInfo(appname::String,
-                app["julia_command"]::String,
-                submodule,
-                app)
+        julia_flags_raw = get(app, "julia_flags", nothing)
+        julia_flags = if julia_flags_raw === nothing
+            String[]
+        else
+            String[flag::String for flag in julia_flags_raw]
+        end
+        appinfo = AppInfo(
+            appname::String,
+            app["julia_command"]::String,
+            submodule,
+            julia_flags,
+            app
+        )
         appinfos[appinfo.name] = appinfo
     end
     return appinfos
@@ -338,6 +347,9 @@ function destructure(manifest::Manifest)::Dict
                 if appinfo.submodule !== nothing
                     app_dict["submodule"] = appinfo.submodule
                 end
+                if !isempty(appinfo.julia_flags)
+                    app_dict["julia_flags"] = appinfo.julia_flags
+                end
                 new_entry["apps"][appname] = app_dict
             end
         end

src/project.jl

@@ -83,7 +83,15 @@ function read_project_apps(raw::Dict{String,Any}, project::Project)
             Expected value for app `$name` to be a dictionary.
         """)
         submodule = get(info, "submodule", nothing)
-        appinfos[name] = AppInfo(name, nothing, submodule, other)
+        julia_flags_raw = get(info, "julia_flags", nothing)
+        julia_flags = if julia_flags_raw === nothing
+            String[]
+        elseif julia_flags_raw isa Vector
+            String[flag::String for flag in julia_flags_raw]
+        else
+            pkgerror("Expected `julia_flags` for app `$name` to be an array of strings")
+        end
+        appinfos[name] = AppInfo(name, nothing, submodule, julia_flags, other)
     end
     return appinfos
 end