Updating moving branch

.github/CODEOWNERS

@@ -4,3 +4,11 @@ CODEOWNERS @JuliaLang/github-actions
 
 /.github/workflows/rerun_failed.yml @DilumAluthge
 /.github/workflows/statuses.yml @DilumAluthge
+/.github/workflows/PrAssignee.yml @LilithHafner @DilumAluthge
+/base/special/ @oscardssmith
+/base/sort.jl @LilithHafner
+/test/sorting.jl @LilithHafner
+/stdlib/*_jll @giordano
+/base/binaryplatforms.jl @giordano
+/src/julia_gcext.h @fingolfin
+/test/gcext/gcext.c @fingolfin

.github/workflows/PrAssignee.yml

@@ -0,0 +1,210 @@
+name: PR Assignee
+on:
+  # Important security note: Do NOT use `actions/checkout`
+  # or any other method for checking out the pull request's source code.
+  # This is because the pull request's source code is untrusted, but the
+  # GITHUB_TOKEN has write permissions (because of the `on: pull_request_target` event).
+  #
+  # Quoting from the GitHub Docs:
+  # > For workflows that are triggered by the pull_request_target event, the GITHUB_TOKEN is granted
+  # > read/write repository permission unless the permissions key is specified and the workflow can access secrets,
+  # > even when it is triggered from a fork.
+  # >
+  # > Although the workflow runs in the context of the base of the pull request,
+  # > you should make sure that you do not check out, build, or run untrusted code from the pull request with this event.
+  #
+  # Source: https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows#pull_request_target
+  #
+  # See also: https://securitylab.github.com/resources/github-actions-preventing-pwn-requests/
+  pull_request_target:
+    types: [opened, reopened, ready_for_review]
+
+# Permissions for the `GITHUB_TOKEN`:
+permissions:
+  pull-requests: write # Needed in order to assign a user as the PR assignee
+
+jobs:
+  pr-assignee:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.draft != true }}
+    steps:
+      # Important security note: As discussed above, do NOT use `actions/checkout`
+      # or any other method for checking out the pull request's source code.
+      # This is because the pull request's source code is untrusted, but the
+      # GITHUB_TOKEN has write permissions (because of the `on: pull_request_target` event).
+      - name: Add Assignee
+        # We pin all third-party actions to a full length commit SHA
+        # https://docs.github.com/en/actions/security-for-github-actions/security-guides/security-hardening-for-github-actions#using-third-party-actions
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          retries: 5 # retry GitHub API requests up to 5 times, with exponential backoff
+          retry-exempt-status-codes: 404
+          # Don't retry 404 because we will hit a 404 when the PR author is a committer.
+          # This 404 is normal and expected.
+          # Do retry 400 and other 4xx errors because github sometimes (erroneously)
+          # returns a 4xx error code due to server errors.
+          script: |
+            const oldPrAssignees = context.payload.pull_request.assignees
+              .map(obj => obj.login)
+            console.log('oldPrAssignees: ', oldPrAssignees);
+            const prAuthor = context.payload.pull_request.user.login;
+
+            // Check if the PR is opened by a collaborator on the repo, aka someone with write (commit) permissions or higher.
+            const relevantPerms = [
+              // 'triage', // Uncomment this line if you don't want PRs from triagers to get auto-assignees.
+              'push',
+              'maintain',
+              'admin',
+            ]
+            const allCollaboratorsNestedPromises = relevantPerms.map(
+              (perm) => github.paginate(
+                // We use the `/repos/{owner}/{repo}/collaborators` endpoint to avoid needing org scope permissions:
+                '/repos/{owner}/{repo}/collaborators',
+                {
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  per_page: 100,
+                  permission: perm,
+                },
+                (response) => response.data.map((collaboratorInfo) => collaboratorInfo.login),
+              )
+            )
+            const allCollaboratorsNested = await Promise.all(allCollaboratorsNestedPromises);
+            const allCollaboratorsFlattened = allCollaboratorsNested.flat();
+
+            // Skip BumpStdlibs.jl PRs
+            allCollaboratorsFlattened.push('DilumAluthgeBot');
+            // Skip Dependabot PRs
+            allCollaboratorsFlattened.push('dependabot');
+
+            const isCollaborator = allCollaboratorsFlattened.includes(prAuthor);
+
+            console.log('prAuthor: ', prAuthor);
+            console.log('isCollaborator: ', isCollaborator);
+
+            // Load the list of assignable reviewers from the JuliaLang/pr-assignment repo at:
+            // https://github.com/JuliaLang/pr-assignment/blob/main/users.txt
+            //
+            // NOTE to JuliaLang committers: If you want to be assigned to new PRs, please add your
+            // GitHub username to that file.
+
+            // Load file contents
+            const { data: fileContentsObj } = await github.rest.repos.getContent({
+              owner: 'JuliaLang',
+              repo: 'pr-assignment',
+              path: 'users.txt',
+              ref: 'main',
+            });
+
+            const fileContentsBufferObj = Buffer.from(fileContentsObj.content, "base64");
+            const fileContentsText = fileContentsBufferObj.toString("utf8");
+
+            // Find lines that match the following regex, and extract the usernames:
+            const regex = /^@([a-zA-Z0-9\-]+)(\s*?)?(#[\S]*?)?$/;
+            const assigneeCandidates = fileContentsText
+              .split('\n')
+              .map(line => line.trim())
+              .map(line => line.match(regex))
+              .filter(match => match !== null)
+              .map(match => match[1]);
+
+            console.log('assigneeCandidates: ', assigneeCandidates);
+            if (assigneeCandidates.length < 1) {
+              const msg = 'ERROR: Could not find any assigneeCandidates';
+              console.error(msg);
+              throw new Error(msg);
+            }
+
+            if (oldPrAssignees.length >= 1) {
+              console.log('Skipping this PR, because it already has at least one assignee');
+              return;
+            }
+
+
+            const RUNNER_DEBUG_original = process.env.RUNNER_DEBUG;
+            console.log('RUNNER_DEBUG_original: ', RUNNER_DEBUG_original);
+            if (RUNNER_DEBUG_original === undefined) {
+              var thisIsActionsRunnerDebugMode = false;
+            } else {
+              const RUNNER_DEBUG_trimmed = RUNNER_DEBUG_original.trim().toLowerCase()
+              if (RUNNER_DEBUG_trimmed.length < 1) {
+                var thisIsActionsRunnerDebugMode = false;
+              } else {
+                var thisIsActionsRunnerDebugMode = (RUNNER_DEBUG_trimmed == 'true') || (RUNNER_DEBUG_trimmed == '1');
+              }
+            }
+            console.log('thisIsActionsRunnerDebugMode: ', thisIsActionsRunnerDebugMode);
+
+            if (isCollaborator == true) {
+
+              if (thisIsActionsRunnerDebugMode) {
+                // The PR author is a committer
+                // But thisIsActionsRunnerDebugMode is true, so we proceed to still run the rest of the script
+                console.log('PR is authored by JuliaLang committer, but thisIsActionsRunnerDebugMode is true, so we will still run the rest of the script: ', prAuthor);
+              } else {
+                // The PR author is a committer, so we skip assigning them
+                console.log('Skipping PR authored by JuliaLang committer: ', prAuthor);
+                console.log('Note: If you want to run the full script (even though the PR author is a committer), simply re-run this job with Actions debug logging enabled');
+                return;
+              }
+            }
+
+            var weDidEncounterError = false;
+
+            // Assign random committer
+            const selectedAssignee = assigneeCandidates[Math.floor(Math.random()*assigneeCandidates.length)]
+            console.log('selectedAssignee: ', selectedAssignee);
+            console.log(`Attempting to assign @${selectedAssignee} to this PR...`);
+            await github.rest.issues.addAssignees({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.payload.pull_request.number,
+              assignees: selectedAssignee,
+            });
+
+            // The following is commented out because the label only makes sense in the presence of a larger state machine
+            // // Add the "pr review" label
+            // const prReviewLabel = 'status: waiting for PR reviewer';
+            // console.log('Attempting to add prReviewLabel to this PR...');
+            // await github.rest.issues.addLabels({
+            //   owner: context.repo.owner,
+            //   repo: context.repo.repo,
+            //   issue_number: context.payload.pull_request.number,
+            //   labels: [prReviewLabel],
+            // });
+
+            // Now get the updated PR info, and see if we were successful:
+            const updatedPrData = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.payload.pull_request.number,
+            });
+            const newPrAssignees = updatedPrData
+              .data
+              .assignees
+              .map(element => element.login)
+            console.log('newPrAssignees: ', newPrAssignees);
+            if (newPrAssignees.includes(selectedAssignee)) {
+              console.log(`Successfully assigned @${selectedAssignee}`);
+            } else {
+              weDidEncounterError = true;
+              console.log(`ERROR: Failed to assign @${selectedAssignee}`);
+            }
+            // const newPrLabels = updatedPrData
+            //   .data
+            //   .labels
+            //   .map(element => element.name)
+            // console.log('newPrLabels: ', newPrLabels);
+            // if (newPrLabels.includes(prReviewLabel)) {
+            //   console.log('Successfully added prReviewLabel');
+            // } else {
+            //   weDidEncounterError = true;
+            //   console.log('ERROR: Failed to add add prReviewLabel');
+            // }
+
+            // Exit with error if any problems were encountered earlier
+            if (weDidEncounterError) {
+              const msg = 'ERROR: Encountered at least one problem while running the script';
+              console.error(msg);
+              throw new Error(msg);
+            }

.github/workflows/Typos.yml

@@ -11,7 +11,7 @@ jobs:
     timeout-minutes: 5
     steps:
       - name: Checkout the JuliaLang/julia repository
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
       - name: Check spelling with typos

.github/workflows/Whitespace.yml

@@ -15,10 +15,10 @@ jobs:
     timeout-minutes: 2
     steps:
       - name: Checkout the JuliaLang/julia repository
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: julia-actions/setup-julia@9b79636afcfb07ab02c256cede01fe2db6ba808c # v2.6.0
+      - uses: julia-actions/setup-julia@5c9647d97b78a5debe5164e9eec09d653d29bd71 # v2.6.1
         with:
           version: '1'
       - name: Check whitespace

.github/workflows/cffconvert.yml

@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out a copy of the repository
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
 

.gitignore

@@ -9,10 +9,12 @@
 /usr-staging
 /Make.user
 /julia-*
+/deps/jlutilities/depot
 /source-dist.tmp
 /source-dist.tmp1
 /test/results_*.json
 /test/results_*.dat
+/test/deps
 
 *.expmap
 *.exe

AGENTS.md

@@ -0,0 +1,103 @@
+# Information for AI agents
+
+## Module Organization
+- `base/` - Core standard library (loaded at startup)
+- `stdlib/` - Standard library packages (can be loaded independently)
+- `Compiler/` - Julia compiler as a separate module (can be swapped)
+- `src/` - C/C++ runtime and LLVM codegen
+- `cli/` - Command-line interface and loader
+- `doc/` - Documentation and User Manual
+
+## Running Julia
+
+You should have a recent binary copy of julia in your `$HOME/.juliaup/bin` directory.
+You may use this julia executable for validation.
+If a built version of Julia exists in the current source tree (at `usr/bin/julia`),
+prefer that version.
+Note that any changes you make to the source code after the binary is built
+will not be reflected, unless you use `Revise`.
+
+## For all changes
+
+1. Run `make check-whitespace` before creating the PR to make sure you're not committing any whitespace errors.
+
+## Building Julia
+
+If you made changes to the runtime (any files in `src/`), you will need to rebuild
+julia. Run `make -j` to rebuild julia. This process may take up to 10 minutes
+depending on your changes.
+
+## Using Revise
+
+If you have made changes to files included in the system image (base/ or stdlib/),
+and need to run code with these changes included, you can use `Revise`.
+To do so, run `using Revise; Revise.track(Base)` (or Revise.track with the stdlib you modified).
+The test system supports doing this automatically (see below).
+
+## Specific instructions for particular changes
+
+### Doctests
+
+#### Writing doctests
+
+If you are asked to write new doctests, first review `doc/src/devdocs/contributing/jldoctests.md`
+for best practices.
+
+#### Verifying doctests
+If you have changed any `jldoctest` code blocks you should take
+the following steps to verify your work:
+- Review `doc/src/devdocs/contributing/jldoctests.md`. In particular, determine
+  if any of the changed doctests require filters, labels or setup code.
+- Run the doctests to verify that your change works:
+    - To run doctest with the pre-built juliaup: `make -C doc doctest=true  revise=true JULIA_EXECUTABLE=$HOME/.juliaup/bin/julia`
+    - To run doctest with in-trr julia (preferred): `make -C doc doctest=true revise=true`. Do not pass any other options.
+    - IMPORTANT: The doctests may take up to 15 minutes. Do NOT terminate the doctests before completion. Do NOT use a timeout for doctests.
+    - If you are ChatGPT, you may have to increase yield_timeout_ms.
+
+Follow these steps for EVERY change you make in a doctest.
+
+### Test changes
+
+If you have changed a test (e.g. `foo`), you should run `make test-revise-foo` for the
+corresponding test to ensure that the test is still passing with your changes.
+- If you are adding a new test, add it to an existing test file. Do not create a new test file unless explicitly instructed.
+- Write one comment at the top of the test to explain what is being tested.
+  Otherwise keep comments minimal.
+- Use the environment variable `JULIA_TEST_FAILFAST=1` to make tests fail fast.
+
+### External dependencies
+
+When modifying external dependencies (patches in `deps/patches/` or version updates in `deps/`):
+
+1. Always test builds with `USE_BINARYBUILDER=0` to ensure source builds work correctly
+2. For patches to external libraries:
+   - Verify the patch applies cleanly by running the extraction and patch steps
+   - Test the full build of the dependency: `make -C deps USE_BINARYBUILDER=0 compile-<depname>`
+   - Prefer using the full upstream commit in `git am` format (e.g., `git format-patch`) which includes proper commit metadata
+3. When updating dependency versions, ensure all associated patches still apply
+
+### Writing code
+After writing code, look up the docstring for each function you used. If there
+are recommendations or additional considerations that apply to these functions,
+make sure to take them into account.
+
+#### Specific instructions
+- Do not `ccall` runtime C functions directly if there are existing wrappers for the function.
+- Do not explicitly add a module prefix if the code you're adding is in the same module. E.g. do not use `Base.` for code in Base unless required.
+
+## Commit message formatting
+
+When writing commit messages, follow the format "component: Brief summary" for
+the title. In the body of the commit message, provide a brief prose summary
+of the purpose of the changes made. Do not specifically mention added tests, comments,
+documentation, etc., unless this is the main purpose of the change. Do not mention
+the test plan, unless it differs from what you were instructed to do in AGENTS.md.
+If your change fixes one or more issues, use the syntax "Fixes #" at the end of the commit message, but do not include it in the title.
+
+When referencing external GitHub PRs or issues, use proper GitHub interlinking format (e.g., `owner/repo#123` for PRs/issues).
+When fixing CI failures, include the link to the specific CI failure in the commit message.
+
+When creating pull requests, if the pull request consists of one commit only,
+use the body of the commit for the body of the pull request. If there are multiple
+commits in the pull request, follow the same guidelines for the pull request
+as for the commit body.

CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md