steep-relaxed 2.0.0.0 → 2.1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06a874321a0387affa79acdee9e6b5dee0541ac453792c7e63fef1e2718f2ce9
-  data.tar.gz: 4566b3de6706976eb3327df058f805b1f9a6ef75bf2acd57a7a23a6a96f4e396
+  metadata.gz: 62c5e1172e3ea8417b507a37c99cdd291db4ee4ab223e84939a47d7f6287800b
+  data.tar.gz: 740ec1d1b15cdfcf9e102379ec0b3a55f68dc710a7ab83fbaec43025f86bd506
 SHA512:
-  metadata.gz: 751a368c57dfe951ab51e7b838f936db50450cbc9b0841e2a6a3a243eb4d8db9a5de5e8911c818d240f964fa2302cc075ddabce40eae248d6d466af02119e475
-  data.tar.gz: 8bd34bedb64e9454d3bfbb9dfd9e8cd92924a212bcd242bcd2882b12272958c420d0dc99297b389cd4f78cbaa993151de2ccdf431106f32ef0f7382d04da011c
+  metadata.gz: d1fbbb8bfb247b14a98a31a3be90ab92303452cbf60a0f9317ca7fe6e6a58351ba59ede725659d0e1e7b9fe284976f5c2bd561ea89966a9d8e4e71f8b0cd86e0
+  data.tar.gz: e52922fcc78b233f8adaf23a771065dc62895367cf4a053b87f405e2ff1f6fcb188c94e8ee863921b2c4a763edc1203651a17c0790dc38897d1c632afdcb349b

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # CHANGELOG
 
+## 2.1.0 (2026-08-27)
+
+Steep 2.1 opens the running server to commands other than the editor's. `steep langserver` now binds
+the per-project UNIX socket that `steep server` serves, so `steep check` and `steep query` reach the
+language server the editor is already running instead of needing a daemon of their own, and the new
+`steep query diagnostics` reads the diagnostics that server has already computed rather than starting
+a type check of its own. Both are aimed at tools that edit files on disk and want fast feedback,
+coding agents in particular.
+
+The type checker gains support for Ruby 3.4's `it` block parameter, and RBS is updated to 4.2.0.
+
+### Type checker core
+
+* Infer tuple types for array literals against pair interface hints like `Hash::_Pair` ([#2253](https://github.com/soutaro/steep/pull/2253))
+* Accept a type alias as the type of a lambda's block parameter ([#2263](https://github.com/soutaro/steep/pull/2263))
+* Build expensive log tags only when something is logged ([#2271](https://github.com/soutaro/steep/pull/2271))
+* Accept block-pass arguments for optional blocks ([#2261](https://github.com/soutaro/steep/pull/2261))
+* feat: support the `it` block parameter ([#2238](https://github.com/soutaro/steep/pull/2238))
+* Fix `UnreachableBranch` on `==` against literal supertype (`Symbol` / `Integer` / `String`) ([#2223](https://github.com/soutaro/steep/pull/2223))
+
+### Commandline tool
+
+* Stop `steep query definition` from hanging on inline sources ([#2276](https://github.com/soutaro/steep/pull/2276))
+* Serve steep query/check through the language server's UNIX socket ([#2273](https://github.com/soutaro/steep/pull/2273))
+* Add `steep query diagnostics` ([#2274](https://github.com/soutaro/steep/pull/2274))
+* Point the Steepfile template, README and CLAUDE.md at rbs collection ([#2269](https://github.com/soutaro/steep/pull/2269))
+
+### Miscellaneous
+
+* Update RBS to 4.2.0 ([#2277](https://github.com/soutaro/steep/pull/2277))
+* Fix `bin/steep-check.rb` for the current API ([#2270](https://github.com/soutaro/steep/pull/2270))
+* Update RBS to 4.2.0.pre.1 ([#2267](https://github.com/soutaro/steep/pull/2267))
+* Fix Ruby warnings printed while running tests ([#2266](https://github.com/soutaro/steep/pull/2266))
+* Run test subprocesses outside the parent Bundler env ([#2225](https://github.com/soutaro/steep/pull/2225))
+
 ## 2.0.0 (2026-04-14)
 
 ### Summary

data/CLAUDE.md

@@ -98,8 +98,8 @@ bundle exec rake build
 **Steepfile**: Defines type checking targets
 - `check`: Directories to type check
 - `signature`: RBS signature directories
-- `library`: Standard library dependencies
-- `collection_config`: External RBS definitions
+- `library`: RBSs that rbs collection doesn't manage
+- `collection_config`: Path to `rbs_collection.yaml` (the project root one is read by default)
 - Multiple targets supported (app, test, bin)
 
 **RBS Collection**: Manages external type definitions via `rbs_collection.steep.yaml`

data/README.md

@@ -34,11 +34,11 @@ Edit the `Steepfile`:
 target :app do
   check "lib"
   signature "sig"
-
-  library "pathname"
 end
 ```
 
+RBSs for the gems in `Gemfile.lock` are loaded via [rbs collection](https://github.com/ruby/rbs/blob/master/docs/collection.md), which you set up with `rbs collection init` and `rbs collection install`. Add a `library` call only for an RBS that rbs collection doesn't manage.
+
 ### 1. Declare Types
 
 Declare types in `.rbs` files in `sig` directory.
@@ -253,7 +253,7 @@ Use `bundle exec rake -T` to see all available tasks.
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. Releases are cut by the `Release gem` workflow rather than from a working copy -- see [doc/release.md](doc/release.md).
 
 ## Contributing
 

data/Rakefile

@@ -36,204 +36,413 @@ end
 #   Rake::Task[:"release:release-prs"].invoke
 # end
 
-desc "Generate changelog template from GH pull requests"
-task :changelog do
-  major, minor, patch, pre = Steep::VERSION.split(".", 4)
-  major = major.to_i
-  minor = minor.to_i
-  patch = patch.to_i
-
-  if patch == 0
-    milestone = "Steep #{major}.#{minor}"
-  else
-    milestone = "Steep #{major}.#{minor}.x"
-  end
+# Pull requests with one of these labels are omitted from the changelog.
+CHANGELOG_SKIP_LABELS = ["skip-changelog"]
+
+# The tags a release proper starts *after*, rather than at.
+CHANGELOG_PRERELEASE_TAGS = ["v*.pre*", "v*.dev*"]
+
+# Resolves the commit-ish the changelog of the release being prepared starts from.
+#
+# `version` is a version number, a tag, or any commit-ish. When it is omitted, the base follows
+# `Steep::VERSION`:
+#
+# * `X.Y.Z.pre.N` documents what changed since `X.Y.Z.pre.N-1`, so it starts from the latest tag.
+# * `X.Y.Z` documents the whole cycle, the prereleases included, so it skips the prerelease tags
+#   in between and starts from the previous release proper.
+#
+# This is the step that is easy to get wrong by hand: on a release proper the latest tag is a
+# prerelease, so the obvious default would produce only the tail of the cycle. Passing a version
+# explicitly overrides all of it.
+#
+def changelog_base(version)
+  require "open3"
 
-  puts "🔍 Finding pull requests that is associated to milestone `#{milestone}`..."
+  from =
+    if version
+      # `2.1.0` and `v2.1.0` both mean the tag `v2.1.0`, while `master` or a SHA is used as is.
+      version.match?(/\A\d/) ? "v#{version}" : version
+    else
+      command = ["git", "describe", "--tags", "--match", "v*", "--abbrev=0"]
+      unless Gem::Version.new(Steep::VERSION).prerelease?
+        CHANGELOG_PRERELEASE_TAGS.each { |glob| command.push("--exclude", glob) }
+      end
 
-  command = [
-    "gh",
-    "pr",
-    "list",
-    "--json",
-    "url,title,number",
-    "--limit=100",
-    "--search" ,
-    "milestone:\"#{milestone}\" is:merged sort:updated-desc -label:Released"
-  ]
+      output, status = Open3.capture2(*command)
+      raise "🚨 Cannot detect the tag the changelog starts from. Give the previous version explicitly." unless status.success?
+      output.chomp
+    end
 
-  require "open3"
-  output, status = Open3.capture2(*command)
-  raise status.inspect unless status.success?
+  _, status = Open3.capture2("git", "rev-parse", "--verify", "--quiet", "#{from}^{commit}")
+  raise "🚨 No such commit-ish: `#{from}`" unless status.success?
 
+  from
+end
+
+# Runs a GraphQL query against the repository of the working directory.
+#
+# `body` is the selection set inside `repository`, so a query can use the `$owner` and `$name`
+# variables. Returns the contents of `data.repository`.
+#
+def changelog_graphql(body)
+  require "open3"
   require "json"
-  json = JSON.parse(output, symbolize_names: true)
 
-  unless json.empty?
-    puts
-    json.each do |line|
-      puts "* #{line[:title]} ([##{line[:number]}](#{line[:url]}))"
+  @changelog_repository ||=
+    begin
+      output, status = Open3.capture2("gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner")
+      raise status.inspect unless status.success?
+      output.chomp.split("/", 2)
     end
-  else
-    puts "  (🤑 There is no *unreleased* pull request associated to the milestone.)"
-  end
+  owner, name = @changelog_repository
+
+  query = <<~GRAPHQL
+    query($owner: String!, $name: String!) {
+      repository(owner: $owner, name: $name) {
+        #{body}
+      }
+    }
+  GRAPHQL
+
+  output, status = Open3.capture2(
+    "gh", "api", "graphql",
+    "-f", "query=#{query}",
+    "-f", "owner=#{owner}",
+    "-f", "name=#{name}",
+    binmode: true
+  )
+  raise status.inspect unless status.success?
+
+  # GitHub always answers in UTF-8, while the default external encoding follows the locale. Without
+  # this, a pull request body with an emoji fails to parse under `LANG=C`, as in GitHub Actions.
+  JSON.parse(output.force_encoding(Encoding::UTF_8), symbolize_names: true).dig(:data, :repository)
 end
 
-namespace :release do
-  desc "Ensure release note"
-  task :note do
-    version = Gem::Version.new(Steep::VERSION)
-    major, minor, patch, pre = Steep::VERSION.split(".", 4)
-    major = major.to_i
-    minor = minor.to_i
-    patch = patch.to_i
+# Lists the commits between `from` and `HEAD`, newest first.
+#
+def changelog_commits(from)
+  require "open3"
 
-    wiki_url = "https://github.com/soutaro/steep/wiki/Release-Note-#{major}.#{minor}"
+  output, status = Open3.capture2("git", "log", "--format=%H", "#{from}..HEAD")
+  raise status.inspect unless status.success?
 
-    puts "🧐 Checking if Release note page already exists..."
+  output.lines.map(&:chomp).reject(&:empty?)
+end
 
-    unless `curl --silent -o/dev/null --head #{wiki_url} -w '%{http_code}'` == "200"
-      pre_flag = version.prerelease? ? " --pre" : ""
-      pre_requirement = version.prerelease? ? ", '~> #{major}.#{minor}.#{patch}.#{pre}'" : ""
+# What `git cherry-pick -x` appends to the message of the commit it creates.
+CHERRY_PICK_ORIGIN = /^\(cherry picked from commit ([0-9a-f]{40})\)$/
+
+# Maps the commits that record where they were cherry-picked from to that commit.
+#
+# A backport is a cherry-pick, so on a release branch it is the recorded origin, not the commit
+# itself, that leads to the pull request the change was written and reviewed in. Without this a
+# backported change is attributed to the pull request that carried the backport, which says
+# nothing about the change and is the same for every commit it brought over.
+#
+# A commit backported twice -- the development line, then a release branch -- carries one line
+# per hop, appended in order, so the first one is where the change started.
+#
+def changelog_origins(commits)
+  return {} if commits.empty?
 
-      puts "----"
+  require "open3"
 
-      puts <<~PREFIX if patch
-        **The latest version of Steep #{major}.#{minor} is `#{pre}`.**
+  # `--no-walk` prints these commits and nothing else. NUL delimiters keep a commit message --
+  # which can contain anything, including what this format looks like -- from being read as the
+  # format itself.
+  output, status = Open3.capture2("git", "log", "--no-walk", "--format=%H%x00%B%x00", *commits, binmode: true)
+  raise status.inspect unless status.success?
 
-      PREFIX
+  # Commit messages are UTF-8, while the default external encoding follows the locale. Without
+  # this, splitting a message that is not ASCII fails under `LANG=C`, as in GitHub Actions.
+  output.force_encoding(Encoding::UTF_8)
 
-      puts <<~TEMPLATE
-        Some of the highlights in Steep #{major}.#{minor} are:
+  output.split("\0").each_slice(2).each_with_object({}) do |(commit, message), origins|
+    commit = commit.to_s.strip
+    next if commit.empty?
 
-        * New feature 1 (URL)
-        * New feature 2 (URL)
-        * New feature 3 (URL)
+    origin = message.to_s[CHERRY_PICK_ORIGIN, 1] or next
+    origins[commit] = origin
+  end
+end
 
-        You can install it with `$ gem install steep#{pre_flag}` or using Bundler.
+# Asks GitHub which pull requests each commit came from, so that any merge strategy -- merge
+# commit, squash, or rebase -- is handled without parsing commit messages.
+#
+# Returns `{ oid => [pull request, ...] }`, with an empty array for the commits GitHub has no
+# merged pull request for, including the ones it does not know at all.
+#
+def changelog_associated_pull_requests(oids)
+  oids.uniq.each_slice(50).each_with_object({}) do |slice, found|
+    aliases = slice.map.with_index do |oid, index|
+      <<~GRAPHQL
+        c#{index}: object(oid: "#{oid}") {
+          ... on Commit {
+            associatedPullRequests(first: 10) {
+              nodes {
+                number title url merged
+                labels(first: 100) { nodes { name } }
+              }
+            }
+          }
+        }
+      GRAPHQL
+    end
 
-        ```rb
-        gem 'steep', require: false#{pre_requirement}
-        ```
+    response = changelog_graphql(aliases.join("\n"))
 
-        See the [CHANGELOG](https://github.com/soutaro/steep/blob/master/CHANGELOG.md) for the details.
+    slice.each_with_index do |oid, index|
+      nodes = response.dig(:"c#{index}", :associatedPullRequests, :nodes) || []
 
-        ## New feature 1
+      found[oid] = nodes.select { |pr| pr[:merged] }.map do |pr|
+        { number: pr[:number], title: pr[:title], url: pr[:url], labels: pr.dig(:labels, :nodes).map { |label| label[:name] } }
+      end
+    end
+  end
+end
 
-        ## New feature 2
+# Finds the pull requests the commits came from, keeping the order of `commits`.
+#
+# Returns the pull requests for the changelog and the ones omitted by `skip_labels`.
+#
+def changelog_pull_requests(commits, skip_labels: CHANGELOG_SKIP_LABELS)
+  origins = changelog_origins(commits)
+  found = changelog_associated_pull_requests(commits.map { |commit| origins[commit] || commit })
+
+  # An origin that leads nowhere -- a commit cherry-picked from a fork, or one that went to the
+  # default branch without a pull request -- falls back to the commit in this history, which is
+  # at least the backport that brought it here.
+  fallbacks = commits.select { |commit| origins[commit] && found.fetch(origins[commit], []).empty? }
+  found.update(changelog_associated_pull_requests(fallbacks)) unless fallbacks.empty?
+
+  pull_requests = {}
+  skipped = {}
+
+  commits.each do |commit|
+    prs = found.fetch(origins[commit] || commit, [])
+    prs = found.fetch(commit, []) if prs.empty?
+
+    prs.each do |pr|
+      if (pr[:labels] & skip_labels).empty?
+        pull_requests[pr[:number]] ||= pr
+      else
+        skipped[pr[:number]] ||= pr
+      end
+    end
+  end
 
-        ## New feature 3
+  [pull_requests.values, skipped.values]
+end
 
-        ## Diagnostics updates
+# Fetches the details that help classifying the pull requests: the changed files and the body.
+#
+def changelog_pull_request_details(pull_requests)
+  pull_requests.each_slice(50).flat_map do |slice|
+    aliases = slice.map do |pr|
+      <<~GRAPHQL
+        p#{pr[:number]}: pullRequest(number: #{pr[:number]}) {
+          body
+          author { login }
+          files(first: 100) {
+            nodes { path }
+            pageInfo { hasNextPage }
+          }
+        }
+      GRAPHQL
+    end
 
-        ## Updating Steep
+    details = changelog_graphql(aliases.join("\n"))
 
-      TEMPLATE
-      puts "----"
-      puts
+    slice.map do |pr|
+      detail = details[:"p#{pr[:number]}"] or next pr
 
-      puts "  ⏩️ Create the release note with the template: #{wiki_url}"
-    else
-      if patch == 0 || version.prerelease?
-        puts "  ⏩️ Open the release note and update it at: #{wiki_url}"
-      else
-        puts "  ✅ Release note is ready!"
-      end
+      pr.merge(
+        author: detail.dig(:author, :login),
+        # The body is a hint for writing the changelog, not a copy source. Keep it short.
+        body: detail[:body].to_s.strip.slice(0, 1000),
+        files: detail.dig(:files, :nodes).map { |file| file[:path] },
+        files_truncated: detail.dig(:files, :pageInfo, :hasNextPage)
+      )
     end
-    puts
   end
+end
 
-  desc "Create GitHub release automatically"
-  task :github do
-    version = Gem::Version.new(Steep::VERSION)
-    major, minor, patch, *_ = Steep::VERSION.split(".")
-    major = major.to_i
-    minor = minor.to_i
-    patch = patch.to_i
-
-    puts "✏️ Making a draft release on GitHub..."
+# Reports the pull requests omitted by their label, so that they do not disappear silently.
+#
+def warn_skipped_pull_requests(skipped, skip_labels)
+  return if skipped.empty?
 
-    content = File.read(File.join(__dir__, "CHANGELOG.md"))
-    changelog = content.scan(/^## \d.*?(?=^## \d)/m)[0]
-    changelog = changelog.sub(/^.*\n^.*\n/, "").rstrip
+  numbers = skipped.map { |pr| "##{pr[:number]}" }
+  numbers = numbers.take(20).push("and #{numbers.size - 20} more") if numbers.size > 20
 
-    notes = <<NOTES
-[Release note](https://github.com/soutaro/steep/wiki/Release-Note-#{major}.#{minor})
+  $stderr.puts
+  $stderr.puts "  (⏭️  Skipped #{skipped.size} pull request(s) labeled #{skip_labels.map { |label| "`#{label}`" }.join(" or ")}: #{numbers.join(", ")})"
+end
 
-#{changelog}
-NOTES
+# Prints the changelog template listing the pull requests merged between `from` and `HEAD`.
+#
+# The changelog goes to STDOUT and everything else goes to STDERR, so that the output can be
+# piped to another command: `rake gem:changelog | pbcopy`
+#
+def print_changelog(from, skip_labels: CHANGELOG_SKIP_LABELS)
+  $stderr.puts "🔍 Finding pull requests merged between `#{from}` and `HEAD`..."
+
+  commits = changelog_commits(from)
+  if commits.empty?
+    $stderr.puts "  (🤔 There is no commit after `#{from}`.)"
+    return
+  end
 
-    command = [
-      "gh",
-      "release",
-      "create",
-      "--draft",
-      "v#{Steep::VERSION}",
-      "--title=#{Steep::VERSION}",
-      "--notes=#{notes}"
-    ]
+  pull_requests, skipped = changelog_pull_requests(commits, skip_labels: skip_labels)
 
-    if version.prerelease?
-      command << "--prerelease"
+  if pull_requests.empty?
+    $stderr.puts "  (🤔 No pull request is associated to the commits after `#{from}`.)"
+  else
+    $stderr.puts
+    pull_requests.each do |pr|
+      puts "* #{pr[:title]} ([##{pr[:number]}](#{pr[:url]}))"
     end
+    $stdout.flush
+  end
 
-    require "open3"
-    output, status = Open3.capture2(*command)
-    if status.success?
-      puts "  ⏩️ Done! Open #{output.chomp} and publish the release!"
-      puts
+  warn_skipped_pull_requests(skipped, skip_labels)
+end
+
+# Prints the same pull requests as `print_changelog` as JSON, with the details that help
+# classifying them into the sections of CHANGELOG.md.
+#
+# This is the input for the release automation, so it always prints a valid JSON document.
+#
+def print_changelog_json(from, skip_labels: CHANGELOG_SKIP_LABELS)
+  require "json"
+
+  $stderr.puts "🔍 Finding pull requests merged between `#{from}` and `HEAD`..."
+
+  commits = changelog_commits(from)
+  pull_requests, skipped = changelog_pull_requests(commits, skip_labels: skip_labels)
+  pull_requests = changelog_pull_request_details(pull_requests)
+
+  $stderr.puts "  (📋 #{pull_requests.size} pull request(s))"
+
+  puts JSON.pretty_generate(
+    {
+      from: from,
+      to: "HEAD",
+      pull_requests: pull_requests,
+      skipped: skipped
+    }
+  )
+  $stdout.flush
+
+  warn_skipped_pull_requests(skipped, skip_labels)
+end
+
+namespace :gem do
+  desc "Generate changelog template from GH pull requests merged since the previous release"
+  task :changelog, [:version] do |_task, args|
+    print_changelog(changelog_base(args[:version]))
+  end
+
+  namespace :changelog do
+    desc "Print the pull requests of `gem:changelog` as JSON, with the changed files and body of each"
+    task :json, [:version] do |_task, args|
+      print_changelog_json(changelog_base(args[:version]))
     end
   end
 
-  desc "Add `Released` labels to pull requests associated to the version"
-  task "release-prs" do
-    major, minor, patch, pre = Steep::VERSION.split(".", 4)
-    major = major.to_i
-    minor = minor.to_i
-    patch = patch.to_i
+  # There are three kinds of release: `X.Y.Z`, `X.Y.Z.pre.N`, and `X.Y.Z.dev.N`. The
+  # `.dev.N` ones are cut from the development line for people who need a specific
+  # change early; they are not written up in the changelog, so there are no notes to
+  # publish and nothing worth announcing.
+  def dev_release?(version)
+    Gem::Version.new(version).segments.include?("dev")
+  end
+
+  # The body of the topmost section of CHANGELOG.md, which is the release being
+  # prepared, minus its own heading.
+  #
+  # The encoding is explicit because the default external encoding follows the
+  # locale, and the changelog is not ASCII.
+  #
+  def changelog_section(version)
+    content = File.read(File.join(__dir__, "CHANGELOG.md"), encoding: Encoding::UTF_8)
+    section = content.scan(/^## \d.*?(?=^## \d)/m)[0] or raise "🚨 Cannot find a release section in CHANGELOG.md"
+    heading, _, body = section.partition("\n")
+    heading.include?(version) or raise "🚨 CHANGELOG.md starts with `#{heading.strip}`, which is not #{version}"
+    body.strip
+  end
+
+  desc "Check that the working tree is ready to be released as the given version"
+  task :check_release, [:version] do |_task, args|
+    version = args[:version] or raise "🚨 Pass the version being released: `rake 'gem:check_release[2.1.0]'`"
+    Gem::Version.correct?(version) or raise "🚨 `#{version}` is not a version number."
+
+    # The version being released and the version the commit declares are stated
+    # separately -- one by whoever starts the release, one by the commit itself --
+    # so that releasing the wrong commit, or releasing the right one under the wrong
+    # name, fails here rather than on RubyGems.
+    version == Steep::VERSION or
+      raise "🚨 Releasing #{version}, but this commit declares `Steep::VERSION = #{Steep::VERSION.inspect}`."
 
-    if patch == 0
-      milestone = "Steep #{major}.#{minor}"
+    if dev_release?(version)
+      puts "✅ #{version} is the version of this commit. It is a dev release, so CHANGELOG.md is not checked."
     else
-      milestone = "Steep #{major}.#{minor}.x"
+      changelog_section(version)
+      puts "✅ #{version} is the version of this commit, and CHANGELOG.md documents it."
     end
+  end
+
+  desc "Create and push the `vX.Y.Z` tag for Steep::VERSION"
+  task :tag do
+    tag = "v#{Steep::VERSION}"
+
+    # Annotated, so that the tag carries its own author and date rather than
+    # borrowing the tagged commit's.
+    sh "git", "tag", "--annotate", "--message", "Steep #{Steep::VERSION}", tag
+    sh "git", "push", "origin", tag
+
+    puts "🏷️  Pushed #{tag}."
+  end
+
+  desc "Publish the GitHub release for Steep::VERSION, unless it is a `.dev.` version"
+  task :gh_release do
+    require "open3"
+
+    version = Gem::Version.new(Steep::VERSION)
+    major, minor, *_ = Steep::VERSION.split(".")
+    tag = "v#{Steep::VERSION}"
 
-    if pre =~ /dev/
-      puts "🔍 Skipping `Released` tags because `dev` release: `#{pre}`"
+    if dev_release?(Steep::VERSION)
+      puts "⏭️  #{Steep::VERSION} is a dev release, so there is no GitHub release to publish."
       next
     end
 
-    puts "🔍 Finding pull requests that is associated to milestone `#{milestone}`..."
+    # The release is created against an existing tag, so that the artifacts and the
+    # notes describe a commit that is already immutable.
+    _, status = Open3.capture2("git", "rev-parse", "--verify", "--quiet", "#{tag}^{commit}")
+    raise "🚨 No such tag: `#{tag}`. Tag the release before creating the GitHub release." unless status.success?
+
+    notes = <<~NOTES
+      [Release note](https://github.com/soutaro/steep/wiki/Release-Note-#{major}.#{minor})
+
+      #{changelog_section(Steep::VERSION)}
+    NOTES
 
+    # Published rather than drafted: the notes are the changelog section that was
+    # already reviewed in the release pull request, so there is nothing left to edit.
     command = [
-      "gh",
-      "pr",
-      "list",
-      "--json",
-      "url,title,number",
-      "--search" ,
-      "milestone:\"#{milestone}\" is:merged sort:updated-desc -label:Released"
+      "gh", "release", "create", tag,
+      "--title=#{Steep::VERSION}",
+      "--notes=#{notes}"
     ]
+    command << "--prerelease" if version.prerelease?
 
-    require "open3"
     output, status = Open3.capture2(*command)
-    raise status.inspect unless status.success?
+    raise "🚨 `gh release create` failed: #{status.inspect}" unless status.success?
 
-    require "json"
-    json = JSON.parse(output, symbolize_names: true)
-
-    puts "  ✅ Found #{json.size} PRs..."
-
-    json.each do |pr|
-      puts "🧐 Updating #{pr[:url]}..."
-      output, status = Open3.capture2("gh", "pr", "edit", pr[:number].to_s, "--add-label", "Released")
-      raise status.inspect unless status.success?
-      puts "  ✅ Done!"
-      sleep 0.5
-    end
+    puts "📝 Released #{tag}: #{output.chomp}"
   end
 end
-
 namespace :rbs do
   task :watch do
     require "listen"

data/Steepfile

@@ -26,6 +26,8 @@ target :app do
   signature "sig"
   ignore_signature "sig/test"
 
+  library "objspace"
+
   implicitly_returns_nil!
 
   configure_code_diagnostics(D::Ruby.strict) do |hash|