diff --git a/.github/dependabot.yml b/.github/dependabot.yml index c980ddc2f4..e97e07d1f1 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -26,7 +26,7 @@ updates: - '/gemfiles/3.4' - '/gemfiles/4.0' - '/gemfiles/4.1' - # - '/gemfiles/typecheck' + - '/gemfiles/memcheck' schedule: interval: 'weekly' groups: diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 782afad346..349c3d8d75 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -42,8 +42,6 @@ jobs: typecheck: runs-on: ubuntu-latest - env: - BUNDLE_GEMFILE: gemfiles/typecheck/Gemfile steps: - uses: actions/checkout@v7 - name: Set up Ruby @@ -261,6 +259,7 @@ jobs: env: BUNDLE_WITH: 'memcheck' BUNDLER_VERSION: '0' + BUNDLE_GEMFILE: gemfiles/memcheck/Gemfile steps: - uses: actions/checkout@v7 - name: Install valgrind diff --git a/.gitignore b/.gitignore index e8dfeddbe6..f4cc19735a 100644 --- a/.gitignore +++ b/.gitignore @@ -31,7 +31,6 @@ out.svg /ext/prism/api_node.c /fuzz/output/ -/gemfiles/typecheck/bin/ /include/prism/ast.h /include/prism/internal/diagnostic.h /javascript/node_modules/ diff --git a/Gemfile b/Gemfile index 77fdd58607..b9a6ab2e94 100644 --- a/Gemfile +++ b/Gemfile @@ -16,9 +16,16 @@ platforms :mri, :windows do gem "ffi" gem "irb" gem "rdoc" +end - group :memcheck, optional: true do - gem "ruby_memcheck" +platforms :mri do + group :typecheck do + gem "rbs", "< 4.1.0" # Until https://github.com/soutaro/steep/issues/2268 is fixed + gem "rbi" + gem "rbs-inline" + gem "sorbet" + gem "steep", ">= 2.1.0.dev.1" + gem "tapioca" end end diff --git a/Gemfile.lock b/Gemfile.lock index 09e274a4c5..942ba8b5ab 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -7,9 +7,13 @@ GEM remote: https://rubygems.org/ specs: ast (2.4.3) + benchmark (0.5.0) benchmark-ips (2.14.0) + concurrent-ruby (1.3.8) + csv (3.3.6) erb (6.0.7) erb (6.0.7-java) + erubi (1.13.1) ffi (1.17.3) ffi (1.17.3-aarch64-linux-gnu) ffi (1.17.3-aarch64-linux-musl) @@ -17,6 +21,7 @@ GEM ffi (1.17.3-x86_64-darwin) ffi (1.17.3-x86_64-linux-gnu) ffi (1.17.3-x86_64-linux-musl) + fileutils (1.8.0) io-console (0.8.2) io-console (0.8.2-java) irb (1.17.0) @@ -24,28 +29,18 @@ GEM prism (>= 1.3.0) rdoc (>= 4.0.0) reline (>= 0.4.2) - jar-dependencies (0.5.7) + json (2.21.2) + json (2.21.2-java) + language_server-protocol (3.17.0.6) + listen (3.10.0) + logger + rb-fsevent (~> 0.10, >= 0.10.3) + rb-inotify (~> 0.9, >= 0.9.10) logger (1.7.0) lrama (0.8.0) - mini_portile2 (2.8.9) - nokogiri (1.19.1) - mini_portile2 (~> 2.8.2) - racc (~> 1.4) - nokogiri (1.19.1-aarch64-linux-gnu) - racc (~> 1.4) - nokogiri (1.19.1-aarch64-linux-musl) - racc (~> 1.4) - nokogiri (1.19.1-arm64-darwin) - racc (~> 1.4) - nokogiri (1.19.1-java) - racc (~> 1.4) - nokogiri (1.19.1-x86_64-darwin) - racc (~> 1.4) - nokogiri (1.19.1-x86_64-linux-gnu) - racc (~> 1.4) - nokogiri (1.19.1-x86_64-linux-musl) - racc (~> 1.4) + netrc (0.11.0) onigmo (0.1.0) + parallel (2.1.0) parser (3.3.10.2) ast (~> 2.4.1) racc @@ -55,19 +50,24 @@ GEM prettyprint (0.2.0) racc (1.8.1) racc (1.8.1-java) + rainbow (3.1.1) rake (13.3.1) rake-compiler (1.3.1) rake rake-compiler-dock (1.12.0) - rbs (4.1.3) - logger - prism (>= 1.6.0) - tsort - rbs (4.1.3-java) - jar-dependencies (>= 0.1.7) + rb-fsevent (0.11.2) + rb-inotify (0.11.1) + ffi (~> 1.0) + rbi (0.4.3) + prism (~> 1.0) + rbs (>= 4.0.1) + rbs (4.0.3) logger prism (>= 1.6.0) tsort + rbs-inline (0.14.0) + prism (>= 0.29) + rbs (~> 4.0) rdoc (8.0.0) erb prism (>= 1.6.0) @@ -75,23 +75,86 @@ GEM tsort reline (0.6.3) io-console (~> 0.5) - ruby_memcheck (3.0.1) - nokogiri + require-hooks (0.4.1) + rexml (3.4.4) ruby_parser (3.22.0) racc (~> 1.5) sexp_processor (~> 4.16) + rubydex (0.3.0) + rubydex (0.3.0-aarch64-linux) + rubydex (0.3.0-arm64-darwin) + rubydex (0.3.0-x86_64-darwin) + rubydex (0.3.0-x86_64-linux) + securerandom (0.4.1) sexp_processor (4.17.5) + sorbet (0.6.13428) + sorbet-static (= 0.6.13428) + sorbet-runtime (0.6.13428) + sorbet-static (0.6.13428-aarch64-linux) + sorbet-static (0.6.13428-java) + sorbet-static (0.6.13428-universal-darwin) + sorbet-static (0.6.13428-x86_64-linux) + sorbet-static-and-runtime (0.6.13428) + sorbet (= 0.6.13428) + sorbet-runtime (= 0.6.13428) + spoom (1.8.7) + erubi (>= 1.10.0) + prism (>= 0.28.0) + rbi (>= 0.4.2) + rbs (>= 4.0.0.dev.5) + rexml (>= 3.2.6) + sorbet-static-and-runtime (>= 0.5.10187) + thor (>= 0.19.2) + steep (2.1.0.dev.1) + concurrent-ruby (>= 1.1.10) + csv (>= 3.0.9) + fileutils (>= 1.1.0) + json (>= 2.1.0) + language_server-protocol (>= 3.17.0.4, < 4.0) + listen (~> 3.0) + logger (>= 1.3.0) + parser (>= 3.2) + prism (>= 0.25.0) + rainbow (>= 2.2.2, < 4.0) + rbs (~> 4.0) + securerandom (>= 0.1) + strscan (>= 1.0.0) + terminal-table (>= 2, < 5) + uri (>= 0.12.0) + strscan (3.1.8) + strscan (3.1.8-java) + tapioca (0.19.2) + benchmark + bundler (>= 2.2.25) + netrc (>= 0.11.0) + parallel (>= 1.21.0) + rbi (>= 0.3.7) + require-hooks (>= 0.2.2) + rubydex (>= 0.1.0.beta10) + sorbet-static-and-runtime (>= 0.6.12698) + spoom (>= 1.7.16) + thor (>= 1.2.0) + tsort + terminal-table (4.0.0) + unicode-display_width (>= 1.1.1, < 4) test-unit (3.7.7) power_assert + thor (1.5.0) tsort (0.2.0) + unicode-display_width (3.2.0) + unicode-emoji (~> 4.1) + unicode-emoji (4.2.0) + uri (1.1.1) PLATFORMS + aarch64-linux aarch64-linux-gnu aarch64-linux-musl arm64-darwin java - ruby + universal-darwin x86_64-darwin + x86_64-linux x86_64-linux-gnu x86_64-linux-musl @@ -106,10 +169,15 @@ DEPENDENCIES rake rake-compiler rake-compiler-dock (~> 1.12.0) + rbi + rbs (< 4.1.0) + rbs-inline rdoc - ruby_memcheck ruby_parser + sorbet + steep (>= 2.1.0.dev.1) + tapioca test-unit BUNDLED WITH - 4.0.4 + 4.0.18 diff --git a/bin/prism b/bin/prism index 43bdea1f36..298b7cb2a2 100755 --- a/bin/prism +++ b/bin/prism @@ -86,7 +86,7 @@ module Prism ["3.1", ["3.1"]], ["3.2", ["3.2"]], ["3.3", ["3.3"]], - ["3.4", ["3.4", "typecheck"]], + ["3.4", ["3.4", "memcheck"]], ["4.0", ["4.0"]], ["4.1", ["4.1"]], ].each do |ruby_version, gemfiles| diff --git a/gemfiles/memcheck/Gemfile b/gemfiles/memcheck/Gemfile new file mode 100644 index 0000000000..a442601522 --- /dev/null +++ b/gemfiles/memcheck/Gemfile @@ -0,0 +1,8 @@ +# frozen_string_literal: true + +source "https://rubygems.org" + +gem "rake-compiler" +gem "rake" +gem "ruby_memcheck" +gem "test-unit" diff --git a/gemfiles/memcheck/Gemfile.lock b/gemfiles/memcheck/Gemfile.lock new file mode 100644 index 0000000000..b0c5545e98 --- /dev/null +++ b/gemfiles/memcheck/Gemfile.lock @@ -0,0 +1,64 @@ +GEM + remote: https://rubygems.org/ + specs: + nokogiri (1.19.4-aarch64-linux-gnu) + racc (~> 1.4) + nokogiri (1.19.4-aarch64-linux-musl) + racc (~> 1.4) + nokogiri (1.19.4-arm-linux-gnu) + racc (~> 1.4) + nokogiri (1.19.4-arm-linux-musl) + racc (~> 1.4) + nokogiri (1.19.4-arm64-darwin) + racc (~> 1.4) + nokogiri (1.19.4-x86_64-darwin) + racc (~> 1.4) + nokogiri (1.19.4-x86_64-linux-gnu) + racc (~> 1.4) + nokogiri (1.19.4-x86_64-linux-musl) + racc (~> 1.4) + power_assert (3.1.0) + racc (1.8.1) + rake (13.4.2) + rake-compiler (1.3.1) + rake + ruby_memcheck (3.0.1) + nokogiri + test-unit (3.7.8) + power_assert + +PLATFORMS + aarch64-linux-gnu + aarch64-linux-musl + arm-linux-gnu + arm-linux-musl + arm64-darwin + x86_64-darwin + x86_64-linux-gnu + x86_64-linux-musl + +DEPENDENCIES + rake + rake-compiler + ruby_memcheck + test-unit + +CHECKSUMS + bundler (4.0.18) sha256=02d9a17429de1847b4e0c9f27a9ee4b20c0a74c0a641b4e77195d6019e3618ac + nokogiri (1.19.4-aarch64-linux-gnu) sha256=1269fb644a6de405057a53dd5c762b1209b43ca7424f839454d3dbc677c31a8f + nokogiri (1.19.4-aarch64-linux-musl) sha256=35c65b9ce72b3bb03207bdbe7067915019dc18c1b9b59139684bd6690fdd01af + nokogiri (1.19.4-arm-linux-gnu) sha256=a301313e38bb065d68239e79734bcd6f56fb6efaacebde29e9abf2a4735340ca + nokogiri (1.19.4-arm-linux-musl) sha256=588923c101bcfa78869734d247d25b598674323e7f22474fc468f6e5647311eb + nokogiri (1.19.4-arm64-darwin) sha256=a46db9853286e6597b36ebc6953817d15acf3a299583eb3f89fdc6f91dd63527 + nokogiri (1.19.4-x86_64-darwin) sha256=7fd17057d3e1f00e9954a74b3cd76595d3d4a5ef233b7ed9599047c204f70551 + nokogiri (1.19.4-x86_64-linux-gnu) sha256=379fae440b28915e3f19d752ce2dcf8465ed2b2fbefd2a7ca0dd497bc981a06a + nokogiri (1.19.4-x86_64-linux-musl) sha256=17dfb7c1fa194ae02fbf7c51a7afc8d278045ab3fdacfd86f91d02d7b274470b + power_assert (3.1.0) sha256=fefe98ed5d3140628138f3f9f9194d6ece01f1320e69700d3c928adca7518251 + racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f + rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701 + rake-compiler (1.3.1) sha256=6b351612b6e2d73ddd5563ee799bb58685176e05363db6758504bd11573d670a + ruby_memcheck (3.0.1) sha256=62d0f0fd20ed887d3269fd6507f6fe626657de4775e7c98acdcae4ff30448c80 + test-unit (3.7.8) sha256=689d1ca53f4d46f678b4e5d68d8e4294f87fc5e8b9238cc4de7c5727e8d65943 + +BUNDLED WITH + 4.0.18 diff --git a/gemfiles/typecheck/Gemfile b/gemfiles/typecheck/Gemfile deleted file mode 100644 index 3965a1c17d..0000000000 --- a/gemfiles/typecheck/Gemfile +++ /dev/null @@ -1,14 +0,0 @@ -# frozen_string_literal: true - -source "https://rubygems.org" - -gem "parser" -gem "rake-compiler" -gem "rake" -gem "rbi" -gem "rbs-inline" -gem "ruby_parser" -gem "sorbet", "<= 0.6.12666" # until tapioca is bumped -gem "steep", ">= 1.7.0.dev.1" -gem "tapioca" -gem "test-unit" diff --git a/gemfiles/typecheck/Gemfile.lock b/gemfiles/typecheck/Gemfile.lock deleted file mode 100644 index a4a0c6a3bb..0000000000 --- a/gemfiles/typecheck/Gemfile.lock +++ /dev/null @@ -1,146 +0,0 @@ -GEM - remote: https://rubygems.org/ - specs: - activesupport (8.1.1) - base64 - bigdecimal - concurrent-ruby (~> 1.0, >= 1.3.1) - connection_pool (>= 2.2.5) - drb - i18n (>= 1.6, < 2) - json - logger (>= 1.4.2) - minitest (>= 5.1) - securerandom (>= 0.3) - tzinfo (~> 2.0, >= 2.0.5) - uri (>= 0.13.1) - ast (2.4.3) - base64 (0.3.0) - benchmark (0.5.0) - bigdecimal (3.3.1) - concurrent-ruby (1.3.7) - connection_pool (2.5.4) - csv (3.3.5) - drb (2.2.3) - erubi (1.13.1) - ffi (1.17.4) - fileutils (1.8.0) - i18n (1.14.7) - concurrent-ruby (~> 1.0) - json (2.19.9) - language_server-protocol (3.17.0.5) - listen (3.9.0) - rb-fsevent (~> 0.10, >= 0.10.3) - rb-inotify (~> 0.9, >= 0.9.10) - logger (1.7.0) - minitest (6.0.1) - prism (~> 1.5) - mutex_m (0.3.0) - netrc (0.11.0) - parallel (1.27.0) - parser (3.3.11.1) - ast (~> 2.4.1) - racc - power_assert (3.0.1) - prism (1.9.0) - racc (1.8.1) - rainbow (3.1.1) - rake (13.3.1) - rake-compiler (1.3.1) - rake - rb-fsevent (0.11.2) - rb-inotify (0.11.1) - ffi (~> 1.0) - rbi (0.3.9) - prism (~> 1.0) - rbs (>= 3.4.4) - rbs (3.10.3) - logger - tsort - rbs-inline (0.13.0) - prism (>= 0.29) - rbs (>= 3.8.0) - rexml (3.4.4) - ruby_parser (3.22.0) - racc (~> 1.5) - sexp_processor (~> 4.16) - securerandom (0.4.1) - sexp_processor (4.17.5) - sorbet (0.6.12666) - sorbet-static (= 0.6.12666) - sorbet-runtime (0.6.12666) - sorbet-static (0.6.12666-universal-darwin) - sorbet-static (0.6.12666-x86_64-linux) - sorbet-static-and-runtime (0.6.12666) - sorbet (= 0.6.12666) - sorbet-runtime (= 0.6.12666) - spoom (1.6.3) - erubi (>= 1.10.0) - prism (>= 0.28.0) - rbi (>= 0.3.3) - rexml (>= 3.2.6) - sorbet-static-and-runtime (>= 0.5.10187) - thor (>= 0.19.2) - steep (1.10.0) - activesupport (>= 5.1) - concurrent-ruby (>= 1.1.10) - csv (>= 3.0.9) - fileutils (>= 1.1.0) - json (>= 2.1.0) - language_server-protocol (>= 3.17.0.4, < 4.0) - listen (~> 3.0) - logger (>= 1.3.0) - mutex_m (>= 0.3.0) - parser (>= 3.1) - rainbow (>= 2.2.2, < 4.0) - rbs (~> 3.9) - securerandom (>= 0.1) - strscan (>= 1.0.0) - terminal-table (>= 2, < 5) - uri (>= 0.12.0) - strscan (3.1.5) - tapioca (0.16.11) - benchmark - bundler (>= 2.2.25) - netrc (>= 0.11.0) - parallel (>= 1.21.0) - rbi (~> 0.2) - sorbet-static-and-runtime (>= 0.5.11087) - spoom (>= 1.2.0) - thor (>= 1.2.0) - yard-sorbet - terminal-table (4.0.0) - unicode-display_width (>= 1.1.1, < 4) - test-unit (3.7.7) - power_assert - thor (1.4.0) - tsort (0.2.0) - tzinfo (2.0.6) - concurrent-ruby (~> 1.0) - unicode-display_width (3.2.0) - unicode-emoji (~> 4.1) - unicode-emoji (4.2.0) - uri (1.1.1) - yard (0.9.44) - yard-sorbet (0.9.0) - sorbet-runtime - yard - -PLATFORMS - arm64-darwin-23 - x86_64-linux - -DEPENDENCIES - parser - rake - rake-compiler - rbi - rbs-inline - ruby_parser - sorbet (<= 0.6.12666) - steep (>= 1.7.0.dev.1) - tapioca - test-unit - -BUNDLED WITH - 2.5.16 diff --git a/lib/prism.rb b/lib/prism.rb index 0ddf668735..0c12df8a14 100644 --- a/lib/prism.rb +++ b/lib/prism.rb @@ -72,7 +72,7 @@ def initialize(version) #-- #: (String source, **untyped options) -> LexCompat::Result def self.lex_compat(source, **options) - LexCompat.new(source, **options).result # steep:ignore + LexCompat.new(source, **options).result end # :call-seq: diff --git a/lib/prism/parse_result.rb b/lib/prism/parse_result.rb index 0d1d2fc845..db03c897b9 100644 --- a/lib/prism/parse_result.rb +++ b/lib/prism/parse_result.rb @@ -1030,7 +1030,7 @@ def deconstruct_keys(keys) # :nodoc: #-- #: () -> void def attach_comments! - Comments.new(self).attach! # steep:ignore + Comments.new(self).attach! end # Walk the tree and mark nodes that are on a new line, loosely emulating @@ -1038,7 +1038,7 @@ def attach_comments! #-- #: () -> void def mark_newlines! - value.accept(Newlines.new(source.offsets.size)) # steep:ignore + value.accept(Newlines.new(source.offsets.size)) end # Returns a string representation of the syntax tree with the errors diff --git a/lib/prism/translation.rb b/lib/prism/translation.rb index 5a086a7542..2495226897 100644 --- a/lib/prism/translation.rb +++ b/lib/prism/translation.rb @@ -6,7 +6,7 @@ module Prism # This module is responsible for converting the prism syntax tree into other # syntax trees. - module Translation # steep:ignore + module Translation autoload :Parser, "prism/translation/parser" autoload :ParserCurrent, "prism/translation/parser_current" autoload :Parser33, "prism/translation/parser_versions" diff --git a/rakelib/test.rake b/rakelib/test.rake index 6ed6dac64b..146323cce1 100644 --- a/rakelib/test.rake +++ b/rakelib/test.rake @@ -53,7 +53,7 @@ namespace :test do RubyMemcheck::TestTask.new(valgrind_internal: :compile, &config) rescue LoadError task :valgrind_internal do - puts "\e[31mruby_memcheck gem not available. Try running with BUNDLE_WITH=memcheck\e[0m" + puts "\e[31mruby_memcheck gem not available. Try running with BUNDLE_GEMFILE=gemfiles/memcheck/Gemfile\e[0m" exit 1 end end diff --git a/rakelib/typecheck.rake b/rakelib/typecheck.rake index ab2d741e06..1d71475236 100644 --- a/rakelib/typecheck.rake +++ b/rakelib/typecheck.rake @@ -68,14 +68,14 @@ namespace :typecheck do abstract = Set.new override = Set.new - if parent && parent.name.name == "Prism" && cls.name.name == "Node" + if parent && parent.name == "Prism" && cls.name == "Node" cls << RBI::Helper.new("abstract") abstract = INODE end if (super_class = node.super_class).is_a?(RBS::AST::Declarations::Class::Super) cls.superclass_name = compile_name(super_class.name) - override = INODE if parent && parent.name.name == "Prism" && super_class.name.name.name == "Node" + override = INODE if parent && parent.name == "Prism" && super_class.name.name == :Node end compiler = RBICompiler.new(cls, abstract: abstract, override: override) @@ -156,10 +156,15 @@ namespace :typecheck do [:deconstruct, :child_nodes] found = parent.nodes.find { |child| child.is_a?(RBI::Method) && child.name == node.old_name.name } parent << - found.dup.tap do |method| - method.name = node.new_name.name - method.comments = compile_comments(node) - end + RBI::Method.new( + node.new_name.name, + params: found.params, + is_singleton: found.is_singleton, + visibility: found.visibility, + sigs: found.sigs, + loc: found.loc, + comments: compile_comments(node), + ) else raise end @@ -288,61 +293,46 @@ namespace :typecheck do end end - def with_gemfile - Bundler.with_original_env do - ENV['BUNDLE_GEMFILE'] = "gemfiles/typecheck/Gemfile" - yield - end - end - desc "Generate RBS with rbs-inline" task rbs_inline: :templates do - with_gemfile do - sh "bundle", "exec", "rbs-inline", "lib", "--output", "lib" - end + sh "bundle", "exec", "rbs-inline", "lib", "--output", "lib" end desc "Generate RBIs from RBSs" task rbi: :templates do - with_gemfile do - require "fileutils" - require "rbs" - require "rbi" - require "set" + require "fileutils" + require "rbs" + require "rbi" + require "set" - rbs_base = File.expand_path("../sig/generated", __dir__) - rbi_base = File.expand_path("../rbi/generated", __dir__) + rbs_base = File.expand_path("../sig/generated", __dir__) + rbi_base = File.expand_path("../rbi/generated", __dir__) - Dir["**/*.rbs", base: rbs_base].each do |filepath| - RBI::File.new(strictness: "true") do |file| - compiler = RBICompiler.new(file) + Dir["**/*.rbs", base: rbs_base].each do |filepath| + RBI::File.new(strictness: "true") do |file| + compiler = RBICompiler.new(file) - _, _, decls = RBS::Parser.parse_signature(File.read(File.join(rbs_base, filepath))) - decls.each { |decl| compiler.compile(decl) } + _, _, decls = RBS::Parser.parse_signature(File.read(File.join(rbs_base, filepath))) + decls.each { |decl| compiler.compile(decl) } - mkdir_p((dirpath = File.join(rbi_base, File.dirname(filepath)))) - File.write(File.join(dirpath, "#{File.basename(filepath, ".rbs")}.rbi"), file.string) - end + mkdir_p((dirpath = File.join(rbi_base, File.dirname(filepath)))) + File.write(File.join(dirpath, "#{File.basename(filepath, ".rbs")}.rbi"), file.string) end end end desc "Typecheck with Steep" task steep: :templates do - with_gemfile do - sh "bundle", "exec", "steep", "check" - end + sh "bundle", "exec", "steep", "check" end desc "Generate RBIs with Tapioca" task tapioca: :templates do Rake::Task["compile:prism"].invoke - with_gemfile do - sh "bundle", "exec", "tapioca", "configure" - sh "bundle", "exec", "tapioca", "gems", "--exclude", "prism" - sh "bundle", "exec", "tapioca", "todo" - end + sh "bundle", "exec", "tapioca", "configure" + sh "bundle", "exec", "tapioca", "gems", "--exclude", "prism" + sh "bundle", "exec", "tapioca", "todo" end desc "Typecheck with Sorbet" @@ -403,8 +393,6 @@ namespace :typecheck do --suppress-error-code=7001 CONFIG - with_gemfile do - sh "bundle", "exec", "srb" - end + sh "bundle", "exec", "srb" end end diff --git a/rbi/generated/prism.rbi b/rbi/generated/prism.rbi index af27809728..914bf4df37 100644 --- a/rbi/generated/prism.rbi +++ b/rbi/generated/prism.rbi @@ -20,7 +20,7 @@ module Prism def self.lex_compat(source, **options); end # Load the serialized AST using the source as a reference into a tree. - sig { params(source: String, serialized: String, freeze: T::Boolean).returns(ParseResult) } + sig { params(source: String, serialized: String, freeze: ::T::Boolean).returns(ParseResult) } def self.load(source, serialized, freeze = T.unsafe(nil)); end # Given a Method, UnboundMethod, Proc, or Thread::Backtrace::Location, @@ -33,54 +33,54 @@ module Prism VERSION = T.let(nil, String) BACKEND = T.let(nil, Symbol) - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } def self.parse(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).void } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).void } def self.profile(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } def self.lex(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } def self.parse_lex(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } def self.dump(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } def self.parse_comments(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(::T::Boolean) } def self.parse_success?(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(::T::Boolean) } def self.parse_failure?(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(stream: ::T.untyped, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } + sig { params(stream: ::T.untyped, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } def self.parse_stream(stream, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } def self.parse_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).void } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).void } def self.profile_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } def self.lex_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } def self.parse_lex_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } def self.dump_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } def self.parse_file_comments(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(::T::Boolean) } def self.parse_file_success?(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: ::T::Boolean, frozen_string_literal: ::T::Boolean, line: Integer, main_script: ::T::Boolean, partial_script: ::T::Boolean, raise_error: ::T.any(Symbol, TrueClass), scopes: T::Array[T::Array[Symbol]], version: String).returns(::T::Boolean) } def self.parse_file_failure?(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), raise_error: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end end diff --git a/rbi/generated/prism/dot_visitor.rbi b/rbi/generated/prism/dot_visitor.rbi index 3de4ec0f50..3704d56ad2 100644 --- a/rbi/generated/prism/dot_visitor.rbi +++ b/rbi/generated/prism/dot_visitor.rbi @@ -11,10 +11,10 @@ module Prism sig { returns(::T.nilable(String)) } attr_reader :value - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } attr_reader :port - sig { params(name: String, value: ::T.nilable(String), port: T::Boolean).void } + sig { params(name: String, value: ::T.nilable(String), port: ::T::Boolean).void } def initialize(name, value, port); end sig { returns(String) } @@ -31,7 +31,7 @@ module Prism sig { params(name: String).void } def initialize(name); end - sig { params(name: String, value: ::T.nilable(String), port: T::Boolean).void } + sig { params(name: String, value: ::T.nilable(String), port: ::T::Boolean).void } def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end sig { returns(String) } diff --git a/rbi/generated/prism/lex_compat.rbi b/rbi/generated/prism/lex_compat.rbi index b1f72a815b..1e210df7fa 100644 --- a/rbi/generated/prism/lex_compat.rbi +++ b/rbi/generated/prism/lex_compat.rbi @@ -44,7 +44,7 @@ module Prism attr_reader :value # Create a new lex compat result object with the given values. - sig { params(value: T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: T::Boolean, source: Source).void } + sig { params(value: T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: ::T::Boolean, source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, continuable, source); end # Implement the hash pattern matching interface for Result. @@ -83,13 +83,13 @@ module Prism # that need to be split on "\\\n" to mimic Ripper's behavior. We also need # to keep track of the state that the heredoc was opened in. class DashHeredoc - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } attr_reader :split sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } attr_reader :tokens - sig { params(split: T::Boolean).void } + sig { params(split: ::T::Boolean).void } def initialize(split); end sig { params(token: [[Integer, Integer], Symbol, String, ::T.untyped]).void } @@ -115,7 +115,7 @@ module Prism sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } attr_reader :tokens - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } attr_reader :dedent_next sig { returns(::T.nilable(Integer)) } @@ -157,7 +157,7 @@ module Prism sig { returns(Result) } def result; end - sig { params(tokens: T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]], source: Source, data_loc: ::T.nilable(Location), bom: T::Boolean, eof_token: ::T.nilable(Token)).returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } + sig { params(tokens: T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]], source: Source, data_loc: ::T.nilable(Location), bom: ::T::Boolean, eof_token: ::T.nilable(Token)).returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } private def post_process_tokens(tokens, source, data_loc, bom, eof_token); end end end diff --git a/rbi/generated/prism/node.rbi b/rbi/generated/prism/node.rbi index 5cb71c8192..17ff9bc2d3 100644 --- a/rbi/generated/prism/node.rbi +++ b/rbi/generated/prism/node.rbi @@ -131,11 +131,11 @@ module Prism attr_reader :flags # Returns true if the node has the newline flag set. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def newline?; end # Returns true if the node has the static literal flag set. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def static_literal?; end # Similar to inspect, but respects the current level of indentation given by @@ -161,10 +161,10 @@ module Prism # particular condition. # # node.breadth_first_search { |node| node.node_id == node_id } - sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(::T.nilable(Node)) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(::T::Boolean)).returns(::T.nilable(Node)) } def breadth_first_search(&blk); end - sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(::T.nilable(Node)) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(::T::Boolean)).returns(::T.nilable(Node)) } def find(&blk); end # Returns all of the nodes that match the given block when visited in a @@ -172,10 +172,10 @@ module Prism # particular condition. # # node.breadth_first_search_all { |node| node.is_a?(Prism::CallNode) } - sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(T::Array[Node]) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(::T::Boolean)).returns(T::Array[Node]) } def breadth_first_search_all(&blk); end - sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(T::Array[Node]) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(::T::Boolean)).returns(T::Array[Node]) } def find_all(&blk); end # Returns a list of the fields that exist for this node class. Fields @@ -321,7 +321,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -418,7 +418,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -503,7 +503,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -594,7 +594,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -650,23 +650,23 @@ module Prism def inspect; end # if the arguments contain forwarding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def contains_forwarding?; end # if the arguments contain keywords - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def contains_keywords?; end # if the arguments contain a keyword splat - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def contains_keyword_splat?; end # if the arguments contain a splat - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def contains_splat?; end # if the arguments contain multiple splats - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def contains_multiple_splats?; end # The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -676,7 +676,7 @@ module Prism sig { returns(T::Array[Node]) } def arguments; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -732,7 +732,7 @@ module Prism def inspect; end # if array contains splat nodes - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def contains_splat?; end # Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array. @@ -775,7 +775,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -908,7 +908,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1002,7 +1002,7 @@ module Prism sig { returns(::T.nilable(String)) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1080,7 +1080,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1143,7 +1143,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1260,7 +1260,7 @@ module Prism sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1338,7 +1338,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1394,7 +1394,7 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # The name of the block local variable. @@ -1404,7 +1404,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1516,7 +1516,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1573,7 +1573,7 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # The name of the block parameter. @@ -1613,7 +1613,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1734,7 +1734,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1812,7 +1812,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -1868,19 +1868,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -1959,7 +1959,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -2030,19 +2030,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -2165,7 +2165,7 @@ module Prism sig { returns(::T.nilable(String)) } def equal; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -2221,19 +2221,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -2315,7 +2315,7 @@ module Prism sig { returns(::T.nilable(String)) } def message; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -2371,19 +2371,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -2462,7 +2462,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -2526,19 +2526,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -2587,7 +2587,7 @@ module Prism sig { returns(String) } def message; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -2672,7 +2672,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -2782,7 +2782,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -2892,7 +2892,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3023,7 +3023,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3120,7 +3120,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3205,7 +3205,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3290,7 +3290,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3353,7 +3353,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3412,7 +3412,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3513,7 +3513,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3598,7 +3598,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3683,7 +3683,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3768,7 +3768,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3844,7 +3844,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -3950,7 +3950,7 @@ module Prism sig { returns(String) } def delimiter; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4026,7 +4026,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4102,7 +4102,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4187,7 +4187,7 @@ module Prism sig { returns(String) } def delimiter; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4281,7 +4281,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4344,7 +4344,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4403,7 +4403,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4504,7 +4504,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4667,7 +4667,7 @@ module Prism sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4765,7 +4765,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4850,7 +4850,7 @@ module Prism sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -4935,7 +4935,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5007,7 +5007,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5096,7 +5096,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5152,7 +5152,7 @@ module Prism sig { returns(::T.nilable(Node)) } def unexpected; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5207,7 +5207,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5346,7 +5346,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5402,7 +5402,7 @@ module Prism def inspect; end # ... operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def exclude_end?; end # Returns the `left` attribute. @@ -5426,7 +5426,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5485,7 +5485,7 @@ module Prism sig { returns(Float) } def value; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5627,7 +5627,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5684,7 +5684,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5740,7 +5740,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5821,7 +5821,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5906,7 +5906,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -5991,7 +5991,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6076,7 +6076,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6139,7 +6139,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6198,7 +6198,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6299,7 +6299,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6396,7 +6396,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6528,7 +6528,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6686,7 +6686,7 @@ module Prism sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6745,7 +6745,7 @@ module Prism sig { returns(::T.any(FloatNode, IntegerNode, RationalNode)) } def numeric; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6810,7 +6810,7 @@ module Prism sig { returns(::T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)) } def value; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6874,7 +6874,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -6963,7 +6963,7 @@ module Prism sig { returns(::T.nilable(String)) } def then_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7019,19 +7019,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # Returns the `receiver` attribute. @@ -7102,7 +7102,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7158,19 +7158,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # Returns the `receiver` attribute. @@ -7241,7 +7241,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7297,19 +7297,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # Returns the `receiver` attribute. @@ -7380,7 +7380,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7444,19 +7444,19 @@ module Prism def inspect; end # &. operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def safe_navigation?; end # a call that could have been a local variable - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def variable_call?; end # a call that is an attribute write, so the value being written should be returned - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def attribute_write?; end # a call that ignores method visibility - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_visibility?; end # Returns the `receiver` attribute. @@ -7497,7 +7497,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7582,7 +7582,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7667,7 +7667,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7752,7 +7752,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7815,7 +7815,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7874,7 +7874,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -7975,7 +7975,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8031,26 +8031,26 @@ module Prism def inspect; end # 0b prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def binary?; end # 0d or no prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def decimal?; end # 0o or 0 prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def octal?; end # 0x prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def hexadecimal?; end # The value of the integer literal as a number. sig { returns(Integer) } def value; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8106,47 +8106,47 @@ module Prism def inspect; end # i - ignores the case of characters when matching - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_case?; end # x - ignores whitespace and allows comments in regular expressions - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def extended?; end # m - allows $ to match the end of lines within strings - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def multi_line?; end # o - only interpolates values into the regular expression once - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def once?; end # e - forces the EUC-JP encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def euc_jp?; end # n - forces the ASCII-8BIT encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ascii_8bit?; end # s - forces the Windows-31J encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def windows_31j?; end # u - forces the UTF-8 encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def utf_8?; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # internal bytes forced the encoding to US-ASCII - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_us_ascii_encoding?; end # Returns the Location represented by `opening_loc`. @@ -8179,7 +8179,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8235,47 +8235,47 @@ module Prism def inspect; end # i - ignores the case of characters when matching - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_case?; end # x - ignores whitespace and allows comments in regular expressions - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def extended?; end # m - allows $ to match the end of lines within strings - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def multi_line?; end # o - only interpolates values into the regular expression once - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def once?; end # e - forces the EUC-JP encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def euc_jp?; end # n - forces the ASCII-8BIT encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ascii_8bit?; end # s - forces the Windows-31J encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def windows_31j?; end # u - forces the UTF-8 encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def utf_8?; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # internal bytes forced the encoding to US-ASCII - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_us_ascii_encoding?; end # Returns the Location represented by `opening_loc`. @@ -8308,7 +8308,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8364,11 +8364,11 @@ module Prism def inspect; end # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def frozen?; end # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def mutable?; end # Returns the Location represented by `opening_loc`. @@ -8401,7 +8401,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8486,7 +8486,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8571,7 +8571,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8626,7 +8626,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8681,7 +8681,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8737,14 +8737,14 @@ module Prism def inspect; end # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def symbol_keys?; end # Returns the `elements` attribute. sig { returns(T::Array[::T.any(AssocNode, AssocSplatNode)]) } def elements; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8801,7 +8801,7 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # Returns the `name` attribute. @@ -8830,7 +8830,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -8936,7 +8936,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9025,7 +9025,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9114,7 +9114,7 @@ module Prism sig { returns(Integer) } def depth; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9203,7 +9203,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9280,7 +9280,7 @@ module Prism sig { returns(Integer) } def depth; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9346,7 +9346,7 @@ module Prism sig { returns(Integer) } def depth; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9461,7 +9461,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9517,47 +9517,47 @@ module Prism def inspect; end # i - ignores the case of characters when matching - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_case?; end # x - ignores whitespace and allows comments in regular expressions - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def extended?; end # m - allows $ to match the end of lines within strings - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def multi_line?; end # o - only interpolates values into the regular expression once - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def once?; end # e - forces the EUC-JP encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def euc_jp?; end # n - forces the ASCII-8BIT encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ascii_8bit?; end # s - forces the Windows-31J encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def windows_31j?; end # u - forces the UTF-8 encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def utf_8?; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # internal bytes forced the encoding to US-ASCII - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_us_ascii_encoding?; end # Returns the Location represented by `opening_loc`. @@ -9603,7 +9603,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9679,7 +9679,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9803,7 +9803,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9866,7 +9866,7 @@ module Prism sig { returns(T::Array[LocalVariableTargetNode]) } def targets; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -9963,7 +9963,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10091,7 +10091,7 @@ module Prism sig { returns(::T.nilable(String)) } def rparen; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10237,7 +10237,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10309,7 +10309,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10364,7 +10364,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10446,7 +10446,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10528,7 +10528,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10587,7 +10587,7 @@ module Prism sig { returns(Integer) } def maximum; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10652,7 +10652,7 @@ module Prism sig { returns(Integer) } def number; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10709,7 +10709,7 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # Returns the `name` attribute. @@ -10729,7 +10729,7 @@ module Prism sig { returns(Node) } def value; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10786,7 +10786,7 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # Returns the `name` attribute. @@ -10819,7 +10819,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10910,7 +10910,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -10994,7 +10994,7 @@ module Prism sig { returns(::T.nilable(::T.any(BlockParameterNode, NoBlockParameterNode))) } def block; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11050,7 +11050,7 @@ module Prism def inspect; end # parentheses that contain multiple potentially void statements - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def multiple_statements?; end # Returns the `body` attribute. @@ -11083,7 +11083,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11193,7 +11193,7 @@ module Prism sig { returns(String) } def rparen; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11271,7 +11271,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11369,7 +11369,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11467,7 +11467,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11527,7 +11527,7 @@ module Prism sig { returns(StatementsNode) } def statements; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11586,7 +11586,7 @@ module Prism def inspect; end # ... operator - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def exclude_end?; end # The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -11623,7 +11623,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11679,19 +11679,19 @@ module Prism def inspect; end # 0b prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def binary?; end # 0d or no prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def decimal?; end # 0o or 0 prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def octal?; end # 0x prefix - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def hexadecimal?; end # The numerator of the rational number. @@ -11706,7 +11706,7 @@ module Prism sig { returns(Integer) } def denominator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11761,7 +11761,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11817,47 +11817,47 @@ module Prism def inspect; end # i - ignores the case of characters when matching - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ignore_case?; end # x - ignores whitespace and allows comments in regular expressions - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def extended?; end # m - allows $ to match the end of lines within strings - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def multi_line?; end # o - only interpolates values into the regular expression once - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def once?; end # e - forces the EUC-JP encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def euc_jp?; end # n - forces the ASCII-8BIT encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def ascii_8bit?; end # s - forces the Windows-31J encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def windows_31j?; end # u - forces the UTF-8 encoding - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def utf_8?; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # internal bytes forced the encoding to US-ASCII - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_us_ascii_encoding?; end # Returns the Location represented by `opening_loc`. @@ -11903,7 +11903,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -11960,7 +11960,7 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # Returns the `name` attribute. @@ -11976,7 +11976,7 @@ module Prism sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12033,14 +12033,14 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # Returns the `name` attribute. sig { returns(Symbol) } def name; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12116,7 +12116,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12231,7 +12231,7 @@ module Prism sig { returns(::T.nilable(String)) } def then_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12288,7 +12288,7 @@ module Prism def inspect; end # a parameter name that has been repeated in the method signature - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def repeated_parameter?; end # Returns the `name` attribute. @@ -12317,7 +12317,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12372,7 +12372,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12444,7 +12444,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12499,7 +12499,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12556,22 +12556,22 @@ module Prism def inspect; end # constant writes that should be modified with shareable constant value literal - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def literal?; end # constant writes that should be modified with shareable constant value experimental everything - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def experimental_everything?; end # constant writes that should be modified with shareable constant value experimental copy - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def experimental_copy?; end # The constant write that should be modified with the shareability state. sig { returns(::T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)) } def write; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12677,7 +12677,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12732,7 +12732,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12788,26 +12788,26 @@ module Prism def inspect; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal` - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def frozen?; end # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def mutable?; end # Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism.parse*` APIs. sig { returns(String) } def filepath; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12862,7 +12862,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12934,7 +12934,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -12993,7 +12993,7 @@ module Prism sig { returns(T::Array[Node]) } def body; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13055,19 +13055,19 @@ module Prism def inspect; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal` - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def frozen?; end # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def mutable?; end # Returns the Location represented by `opening_loc`. @@ -13113,7 +13113,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13220,7 +13220,7 @@ module Prism sig { returns(::T.nilable(String)) } def rparen; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13279,15 +13279,15 @@ module Prism def inspect; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # internal bytes forced the encoding to US-ASCII - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_us_ascii_encoding?; end # Returns the Location represented by `opening_loc`. @@ -13333,7 +13333,7 @@ module Prism sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13388,7 +13388,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13460,7 +13460,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13594,7 +13594,7 @@ module Prism sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13653,7 +13653,7 @@ module Prism def inspect; end # a loop after a begin statement, so the body is executed first before the condition - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def begin_modifier?; end # Returns the Location represented by `until_keyword_loc`. @@ -13703,7 +13703,7 @@ module Prism sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13794,7 +13794,7 @@ module Prism sig { returns(::T.nilable(String)) } def then_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13853,7 +13853,7 @@ module Prism def inspect; end # a loop after a begin statement, so the body is executed first before the condition - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def begin_modifier?; end # Returns the Location represented by `while_keyword_loc`. @@ -13903,7 +13903,7 @@ module Prism sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -13959,11 +13959,11 @@ module Prism def inspect; end # internal bytes forced the encoding to UTF-8 - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_utf8_encoding?; end # internal bytes forced the encoding to binary - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def forced_binary_encoding?; end # Returns the Location represented by `opening_loc`. @@ -14009,7 +14009,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end @@ -14107,7 +14107,7 @@ module Prism sig { returns(::T.nilable(String)) } def rparen; end - sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(::T::Boolean)) } def ===(other); end end diff --git a/rbi/generated/prism/node_ext.rbi b/rbi/generated/prism/node_ext.rbi index 589007ddcc..0323d3cc13 100644 --- a/rbi/generated/prism/node_ext.rbi +++ b/rbi/generated/prism/node_ext.rbi @@ -45,25 +45,25 @@ module Prism module HeredocQuery # Returns true if this node was represented as a heredoc in the source code. - sig { params(opening: ::T.nilable(String)).returns(::T.nilable(T::Boolean)) } + sig { params(opening: ::T.nilable(String)).returns(::T.nilable(::T::Boolean)) } def self.heredoc?(opening); end end class InterpolatedStringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(::T.nilable(T::Boolean)) } + sig { returns(::T.nilable(::T::Boolean)) } def heredoc?; end end class InterpolatedXStringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(::T.nilable(T::Boolean)) } + sig { returns(::T.nilable(::T::Boolean)) } def heredoc?; end end class StringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(::T.nilable(T::Boolean)) } + sig { returns(::T.nilable(::T::Boolean)) } def heredoc?; end # Occasionally it's helpful to treat a string as if it were interpolated so @@ -74,7 +74,7 @@ module Prism class XStringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(::T.nilable(T::Boolean)) } + sig { returns(::T.nilable(::T::Boolean)) } def heredoc?; end # Occasionally it's helpful to treat a string as if it were interpolated so diff --git a/rbi/generated/prism/parse_result.rbi b/rbi/generated/prism/parse_result.rbi index 8d1d5c6e82..ee5c1d8140 100644 --- a/rbi/generated/prism/parse_result.rbi +++ b/rbi/generated/prism/parse_result.rbi @@ -379,7 +379,7 @@ module Prism def pretty_print(q); end # Returns true if the given other location is equal to this location. - sig { params(other: ::T.untyped).returns(T::Boolean) } + sig { params(other: ::T.untyped).returns(::T::Boolean) } def ==(other); end # Returns a new location that stretches from this location to the given @@ -417,7 +417,7 @@ module Prism # Returns true if this comment happens on the same line as other code and # false if the comment is by itself. This can only be true for inline # comments and should be false for block comments. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def trailing?; end end @@ -426,7 +426,7 @@ module Prism class InlineComment < Comment # Returns true if this comment happens on the same line as other code and # false if the comment is by itself. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def trailing?; end # Returns a string representation of this comment. @@ -438,7 +438,7 @@ module Prism # and =end. class EmbDocComment < Comment # Returns false. This can only be true for inline comments. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def trailing?; end # Returns a string representation of this comment. @@ -572,7 +572,7 @@ module Prism attr_reader :source # Create a new result object with the given values. - sig { params(comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: T::Boolean, source: Source).void } + sig { params(comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: ::T::Boolean, source: Source).void } def initialize(comments, magic_comments, data_loc, errors, warnings, continuable, source); end # Implement the hash pattern matching interface for Result. @@ -585,12 +585,12 @@ module Prism # Returns true if there were no errors during parsing and false if there # were. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def success?; end # Returns true if there were errors during parsing and false if there were # not. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def failure?; end # Returns true if the parsed source is an incomplete expression that could @@ -613,7 +613,7 @@ module Prism # Prism.parse("tap do").continuable? #=> true (unclosed block) # Prism.parse("end.tap do").continuable? #=> false (stray end) # - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def continuable?; end # Create a code units cache for the given encoding. @@ -628,7 +628,7 @@ module Prism attr_reader :value # Create a new parse result object with the given values. - sig { params(value: ProgramNode, comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: T::Boolean, source: Source).void } + sig { params(value: ProgramNode, comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: ::T::Boolean, source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, continuable, source); end # Implement the hash pattern matching interface for ParseResult. @@ -657,7 +657,7 @@ module Prism attr_reader :value # Create a new lex result object with the given values. - sig { params(value: T::Array[Token], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: T::Boolean, source: Source).void } + sig { params(value: T::Array[Token], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: ::T::Boolean, source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, continuable, source); end # Implement the hash pattern matching interface for LexResult. @@ -673,7 +673,7 @@ module Prism attr_reader :value # Create a new parse lex result object with the given values. - sig { params(value: [ProgramNode, T::Array[Token]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: T::Boolean, source: Source).void } + sig { params(value: [ProgramNode, T::Array[Token]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], continuable: ::T::Boolean, source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, continuable, source); end # Implement the hash pattern matching interface for ParseLexResult. @@ -712,7 +712,7 @@ module Prism def pretty_print(q); end # Returns true if the given other token is equal to this token. - sig { params(other: ::T.untyped).returns(T::Boolean) } + sig { params(other: ::T.untyped).returns(::T::Boolean) } def ==(other); end # Returns a string representation of this token. diff --git a/rbi/generated/prism/parse_result/comments.rbi b/rbi/generated/prism/parse_result/comments.rbi index f386d03f34..6e70c6f47b 100644 --- a/rbi/generated/prism/parse_result/comments.rbi +++ b/rbi/generated/prism/parse_result/comments.rbi @@ -32,7 +32,7 @@ module Prism sig { returns(Integer) } def end_offset; end - sig { params(comment: Comment).returns(T::Boolean) } + sig { params(comment: Comment).returns(::T::Boolean) } def encloses?(comment); end sig { params(comment: Comment).void } @@ -57,7 +57,7 @@ module Prism sig { returns(Integer) } def end_offset; end - sig { params(comment: Comment).returns(T::Boolean) } + sig { params(comment: Comment).returns(::T::Boolean) } def encloses?(comment); end sig { params(comment: Comment).void } diff --git a/rbi/generated/prism/parse_result/newlines.rbi b/rbi/generated/prism/parse_result/newlines.rbi index f77dee3bbf..f8eba73d75 100644 --- a/rbi/generated/prism/parse_result/newlines.rbi +++ b/rbi/generated/prism/parse_result/newlines.rbi @@ -52,70 +52,70 @@ module Prism class Node abstract! - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def newline_flag?; end - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class BeginNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class ParenthesesNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class IfNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class UnlessNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class UntilNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class WhileNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class RescueModifierNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class InterpolatedMatchLastLineNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class InterpolatedRegularExpressionNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class InterpolatedStringNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class InterpolatedSymbolNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end class InterpolatedXStringNode < Node - sig { params(lines: T::Array[T::Boolean]).void } + sig { params(lines: T::Array[::T::Boolean]).void } def newline_flag!(lines); end end end diff --git a/rbi/generated/prism/serialize.rbi b/rbi/generated/prism/serialize.rbi index ec84dfdfb8..0180ad0608 100644 --- a/rbi/generated/prism/serialize.rbi +++ b/rbi/generated/prism/serialize.rbi @@ -19,14 +19,14 @@ module Prism # # The formatting of the source of this method is purposeful to illustrate # the structure of the serialized data. - sig { params(input: String, serialized: String, freeze: T::Boolean).returns(ParseResult) } + sig { params(input: String, serialized: String, freeze: ::T::Boolean).returns(ParseResult) } def self.load_parse(input, serialized, freeze); end # Deserialize the dumped output from a request to lex or lex_file. # # The formatting of the source of this method is purposeful to illustrate # the structure of the serialized data. - sig { params(input: String, serialized: String, freeze: T::Boolean).returns(LexResult) } + sig { params(input: String, serialized: String, freeze: ::T::Boolean).returns(LexResult) } def self.load_lex(input, serialized, freeze); end # Deserialize the dumped output from a request to parse_comments or @@ -34,7 +34,7 @@ module Prism # # The formatting of the source of this method is purposeful to illustrate # the structure of the serialized data. - sig { params(input: String, serialized: String, freeze: T::Boolean).returns(T::Array[Comment]) } + sig { params(input: String, serialized: String, freeze: ::T::Boolean).returns(T::Array[Comment]) } def self.load_parse_comments(input, serialized, freeze); end # Deserialize the dumped output from a request to parse_lex or @@ -42,7 +42,7 @@ module Prism # # The formatting of the source of this method is purposeful to illustrate # the structure of the serialized data. - sig { params(input: String, serialized: String, freeze: T::Boolean).returns(ParseLexResult) } + sig { params(input: String, serialized: String, freeze: ::T::Boolean).returns(ParseLexResult) } def self.load_parse_lex(input, serialized, freeze); end class ConstantPool @@ -71,7 +71,7 @@ module Prism sig { params(source: Source, serialized: String).void } def initialize(source, serialized); end - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def eof?; end sig { params(constant_pool: ConstantPool).void } @@ -83,13 +83,13 @@ module Prism sig { returns(Encoding) } def load_encoding; end - sig { params(freeze: T::Boolean).returns(T::Array[Integer]) } + sig { params(freeze: ::T::Boolean).returns(T::Array[Integer]) } def load_line_offsets(freeze); end - sig { params(freeze: T::Boolean).returns(T::Array[Comment]) } + sig { params(freeze: ::T::Boolean).returns(T::Array[Comment]) } def load_comments(freeze); end - sig { params(freeze: T::Boolean).returns(T::Array[MagicComment]) } + sig { params(freeze: ::T::Boolean).returns(T::Array[MagicComment]) } def load_magic_comments(freeze); end DIAGNOSTIC_TYPES = T.let(nil, T::Array[Symbol]) @@ -97,13 +97,13 @@ module Prism sig { returns(Symbol) } def load_error_level; end - sig { params(encoding: Encoding, freeze: T::Boolean).returns(T::Array[ParseError]) } + sig { params(encoding: Encoding, freeze: ::T::Boolean).returns(T::Array[ParseError]) } def load_errors(encoding, freeze); end sig { returns(Symbol) } def load_warning_level; end - sig { params(encoding: Encoding, freeze: T::Boolean).returns(T::Array[ParseWarning]) } + sig { params(encoding: Encoding, freeze: ::T::Boolean).returns(T::Array[ParseWarning]) } def load_warnings(encoding, freeze); end sig { returns(T::Array[Token]) } @@ -123,34 +123,34 @@ module Prism sig { returns(Float) } def load_double; end - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def load_bool; end sig { returns(Integer) } def load_uint32; end - sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean).returns(::T.nilable(Node)) } + sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: ::T::Boolean).returns(::T.nilable(Node)) } def load_optional_node(constant_pool, encoding, freeze); end sig { params(encoding: Encoding).returns(String) } def load_string(encoding); end - sig { params(freeze: T::Boolean).returns(Location) } + sig { params(freeze: ::T::Boolean).returns(Location) } def load_location_object(freeze); end # Load a location object from the serialized data. Note that we are lying # about the signature a bit here, because we sometimes load it as a packed # integer instead of an object. - sig { params(freeze: T::Boolean).returns(Location) } + sig { params(freeze: ::T::Boolean).returns(Location) } def load_location(freeze); end # Load an optional location object from the serialized data if it is # present. Note that we are lying about the signature a bit here, because # we sometimes load it as a packed integer instead of an object. - sig { params(freeze: T::Boolean).returns(::T.nilable(Location)) } + sig { params(freeze: ::T::Boolean).returns(::T.nilable(Location)) } def load_optional_location(freeze); end - sig { params(freeze: T::Boolean).returns(::T.nilable(Location)) } + sig { params(freeze: ::T::Boolean).returns(::T.nilable(Location)) } def load_optional_location_object(freeze); end sig { params(constant_pool: ConstantPool, encoding: Encoding).returns(Symbol) } @@ -159,7 +159,7 @@ module Prism sig { params(constant_pool: ConstantPool, encoding: Encoding).returns(::T.nilable(Symbol)) } def load_optional_constant(constant_pool, encoding); end - sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean).returns(Node) } + sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: ::T::Boolean).returns(Node) } def load_node(constant_pool, encoding, freeze); end sig { void } diff --git a/rbi/generated/prism/string_query.rbi b/rbi/generated/prism/string_query.rbi index 688ea4f08b..5747aaa0b4 100644 --- a/rbi/generated/prism/string_query.rbi +++ b/rbi/generated/prism/string_query.rbi @@ -4,13 +4,13 @@ module Prism # Query methods that allow categorizing strings based on their context for # where they could be valid in a Ruby syntax tree. class StringQuery - sig { params(string: String).returns(T::Boolean) } + sig { params(string: String).returns(::T::Boolean) } def self.local?(string); end - sig { params(string: String).returns(T::Boolean) } + sig { params(string: String).returns(::T::Boolean) } def self.constant?(string); end - sig { params(string: String).returns(T::Boolean) } + sig { params(string: String).returns(::T::Boolean) } def self.method_name?(string); end # The string that this query is wrapping. @@ -22,15 +22,15 @@ module Prism def initialize(string); end # Whether or not this string is a valid local variable name. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def local?; end # Whether or not this string is a valid constant name. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def constant?; end # Whether or not this string is a valid method name. - sig { returns(T::Boolean) } + sig { returns(::T::Boolean) } def method_name?; end end end diff --git a/sig/generated/prism/node_ext.rbs b/sig/generated/prism/node_ext.rbs index be8cc59abc..404a1ad90a 100644 --- a/sig/generated/prism/node_ext.rbs +++ b/sig/generated/prism/node_ext.rbs @@ -213,6 +213,7 @@ module Prism def full_message_loc: () -> Location? end + # :stopdoc: class InNode < Node # : () -> String def in: () -> String