Bugs/typos found by AI

.github/workflows/Downstream.yml

@@ -0,0 +1,48 @@
+name: IntegrationTest
+on:
+  push:
+    branches: [master]
+    tags: [v*]
+  pull_request:
+
+jobs:
+  test:
+    name: ${{ matrix.package.repo }}/${{ matrix.julia-version }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        julia-version: [1]
+        os: [ubuntu-latest]
+        package:
+          - {user: timholy, repo: Revise.jl}
+
+    steps:
+      - uses: actions/checkout@v6
+      - uses: julia-actions/setup-julia@v3
+        with:
+          version: ${{ matrix.julia-version }}
+      - uses: julia-actions/julia-buildpkg@v1
+      - name: Clone Downstream
+        uses: actions/checkout@v6
+        with:
+          repository: ${{ matrix.package.user }}/${{ matrix.package.repo }}
+          path: downstream
+      - name: Load this and run the downstream tests
+        shell: julia --color=yes --project=downstream {0}
+        run: |
+          using Pkg
+          try
+            # force it to use this PR's version of the package
+            Pkg.develop(PackageSpec(path="."))  # resolver may fail with main deps
+            Pkg.update()
+            Pkg.test()  # resolver may fail with test time deps
+          catch err
+            err isa Pkg.Resolve.ResolverError || rethrow()
+            # If we can't resolve that means this is incompatible by SemVer and this is fine
+            # It means we marked this as a breaking change, so we don't need to worry about
+            # Mistakenly introducing a breaking change, as we have intentionally made one
+            @info "Not compatible with this release. No problem." exception=err
+            exit(0)  # Exit immediately, as a success
+          end

docs/src/api.md

@@ -5,6 +5,7 @@
 ```@docs
 signature
 methoddef!
+methoddefs!
 rename_framemethods!
 bodymethod
 ```

docs/src/edges.md

@@ -79,7 +79,7 @@ julia> lwr = Meta.lower(Main, ex)
 and then extract the edges:
 
 ```julia
-julia> edges = CodeEdges(lwr.args[1])
+julia> edges = CodeEdges(Main, lwr.args[1])
 CodeEdges:
   s: assigned on [1, 16], depends on [15], and used by [12, 15]
   k: assigned on [2, 18], depends on [17], and used by [11, 17]
@@ -188,7 +188,7 @@ Suppose we want to evaluate just the lines needed to compute `s`.
 We can find out which lines these are with
 
 ```julia
-julia> isrequired = lines_required(:s, lwr.args[1], edges)
+julia> isrequired = lines_required(GlobalRef(Main, :s), lwr.args[1], edges)
 24-element BitArray{1}:
  1
  0

docs/src/signatures.md

@@ -90,8 +90,8 @@ end)))
 
 This reveals the *three* methods actually got defined:
 - one method of `f` with a single positional argument (this is the second 3-argument `:method` expression)
-- a keyword-handling method that checks the names of supplied keyword arguments and fills in defaults (this is the third 3-argument `:method` expression).  This method can be obtained from `Core.kwfunc(f)`, which returns a function named `f##kw`.
-- a "keyword-body" method that actually does the work specifies by our function definition. This method gets called by the other two. (This is the first 3-argument `:method` expression.)
+- a keyword-handling method that checks the names of supplied keyword arguments and fills in defaults (this is the third 3-argument `:method` expression). Its keyword-dispatch function can be obtained from `Core.kwfunc(f)` (on supported Julia versions this is `Core.kwcall`).
+- a "keyword-body" method that actually does the work specified by our function definition. This method gets called by the other two. (This is the first 3-argument `:method` expression.)
 
 From examining the lowered code we might guess that this function is called `#f#2`.
 What happens if we try to get it?