From a982a15bfb7c04fec5123f5aeb8fe65acd8681fc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 2 May 2022 19:22:11 +0000 Subject: [PATCH 1/7] build(deps-dev): bump sorbet in /Library/Homebrew Bumps [sorbet](https://github.com/sorbet/sorbet) from 0.5.9889 to 0.5.9959. - [Release notes](https://github.com/sorbet/sorbet/releases) - [Commits](https://github.com/sorbet/sorbet/commits) --- updated-dependencies: - dependency-name: sorbet dependency-type: direct:development update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- Library/Homebrew/Gemfile.lock | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock index 4fa5678190..21d67956e5 100644 --- a/Library/Homebrew/Gemfile.lock +++ b/Library/Homebrew/Gemfile.lock @@ -157,11 +157,11 @@ GEM simplecov (~> 0.19) simplecov-html (0.12.3) simplecov_json_formatter (0.1.4) - sorbet (0.5.9889) - sorbet-static (= 0.5.9889) + sorbet (0.5.9959) + sorbet-static (= 0.5.9959) sorbet-runtime (0.5.9889) sorbet-runtime-stub (0.2.0) - sorbet-static (0.5.9889-universal-darwin-14) + sorbet-static (0.5.9959-universal-darwin-14) spoom (1.1.11) sorbet (>= 0.5.9204) sorbet-runtime (>= 0.5.9204) From 3877df2eac5d4ee81955c7500c7d5c03d1f874c7 Mon Sep 17 00:00:00 2001 From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com> Date: Mon, 2 May 2022 19:28:34 +0000 Subject: [PATCH 2/7] brew vendor-gems: commit updates. --- Library/Homebrew/Gemfile.lock | 2 +- Library/Homebrew/vendor/bundle/bundler/setup.rb | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock index 21d67956e5..9854e36020 100644 --- a/Library/Homebrew/Gemfile.lock +++ b/Library/Homebrew/Gemfile.lock @@ -159,7 +159,7 @@ GEM simplecov_json_formatter (0.1.4) sorbet (0.5.9959) sorbet-static (= 0.5.9959) - sorbet-runtime (0.5.9889) + sorbet-runtime (0.5.9959) sorbet-runtime-stub (0.2.0) sorbet-static (0.5.9959-universal-darwin-14) spoom (1.1.11) diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb index 408dd341a1..5001a6b3ea 100644 --- a/Library/Homebrew/vendor/bundle/bundler/setup.rb +++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb @@ -58,7 +58,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel-1.22.1/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel_tests-3.8.1/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parser-3.1.2.0/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rainbow-3.1.1/lib" -$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.9889/lib" +$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.9959/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-6.0.1/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib" @@ -94,8 +94,8 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-html-0.12.3 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov_json_formatter-0.1.4/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-0.21.2/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-cobertura-2.1.0/lib" -$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.9889-universal-darwin-14/lib" -$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.9889/lib" +$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.9959-universal-darwin-14/lib" +$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.9959/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-stub-0.2.0/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/thor-1.2.1/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/spoom-1.1.11/lib" From 457805959c36e8a954cd725543df95f4b1680680 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 18 Apr 2022 18:04:08 +0000 Subject: [PATCH 3/7] build(deps-dev): bump parlour from 6.0.1 to 7.0.0 in /Library/Homebrew Bumps [parlour](https://github.com/AaronC81/parlour) from 6.0.1 to 7.0.0. - [Release notes](https://github.com/AaronC81/parlour/releases) - [Changelog](https://github.com/AaronC81/parlour/blob/master/CHANGELOG.md) - [Commits](https://github.com/AaronC81/parlour/compare/6.0.1...7.0.0) --- updated-dependencies: - dependency-name: parlour dependency-type: direct:development update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- Library/Homebrew/Gemfile.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock index 9854e36020..078ac3a65a 100644 --- a/Library/Homebrew/Gemfile.lock +++ b/Library/Homebrew/Gemfile.lock @@ -68,7 +68,7 @@ GEM parallel (1.22.1) parallel_tests (3.8.1) parallel - parlour (6.0.1) + parlour (7.0.0) commander (~> 4.5) parser rainbow (~> 3.0) From 5de4756e3a9f6af6519beb87f9d13d517fd7b20d Mon Sep 17 00:00:00 2001 From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com> Date: Mon, 18 Apr 2022 18:06:35 +0000 Subject: [PATCH 4/7] brew vendor-gems: commit updates. --- Library/Homebrew/vendor/bundle/bundler/setup.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb index 5001a6b3ea..f095f92066 100644 --- a/Library/Homebrew/vendor/bundle/bundler/setup.rb +++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb @@ -59,7 +59,7 @@ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel_tests-3.8.1/ $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parser-3.1.2.0/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rainbow-3.1.1/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.9959/lib" -$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-6.0.1/lib" +$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-7.0.0/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib" $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/pry-0.14.1/lib" From 48bf0cc7ad6acc119e75072b170a0b0ca4a5de9a Mon Sep 17 00:00:00 2001 From: Bo Anderson Date: Mon, 2 May 2022 20:48:42 +0100 Subject: [PATCH 5/7] Update RBI files for parlour. --- .../sorbet/rbi/gems/parlour@6.0.1.rbi | 1614 ------------ .../sorbet/rbi/gems/parlour@7.0.0.rbi | 2154 +++++++++++++++++ .../sorbet/rbi/hidden-definitions/hidden.rbi | 10 +- 3 files changed, 2163 insertions(+), 1615 deletions(-) delete mode 100644 Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/parlour@7.0.0.rbi diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi deleted file mode 100644 index 75604863db..0000000000 --- a/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi +++ /dev/null @@ -1,1614 +0,0 @@ -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `parlour` gem. -# Please instead update this file by running `bin/tapioca gem parlour`. - -# typed: true - -module Kernel - extend ::Forwardable -end - -module Parlour; end - -class Parlour::ConflictResolver - sig { params(namespace: Parlour::RbiGenerator::Namespace, resolver: T.proc.params(desc: String, choices: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T.nilable(Parlour::RbiGenerator::RbiObject))).void } - def resolve_conflicts(namespace, &resolver); end - - private - - sig { params(arr: T::Array[T.untyped]).returns(T::Boolean) } - def all_eql?(arr); end - - sig { params(namespace: Parlour::RbiGenerator::Namespace, name: T.nilable(String)).void } - def deduplicate_mixins_of_name(namespace, name); end - - sig { params(arr: T::Array[T.untyped]).returns(T.nilable(Symbol)) } - def merge_strategy(arr); end -end - -module Parlour::Conversion; end - -class Parlour::Conversion::Converter - abstract! - - def initialize; end - - sig { params(msg: String, node: Parlour::RbiGenerator::RbiObject).void } - def add_warning(msg, node); end - - sig { returns(T::Array[[String, Parlour::TypedObject]]) } - def warnings; end -end - -class Parlour::Conversion::RbiToRbs < ::Parlour::Conversion::Converter - sig { params(rbs_gen: Parlour::RbsGenerator).void } - def initialize(rbs_gen); end - - sig { params(from: Parlour::RbiGenerator::Namespace, to: Parlour::RbsGenerator::Namespace).void } - def convert_all(from, to); end - - sig { params(node: Parlour::RbiGenerator::RbiObject, new_parent: Parlour::RbsGenerator::Namespace).void } - def convert_object(node, new_parent); end - - sig { returns(Parlour::RbsGenerator) } - def rbs_gen; end -end - -module Parlour::Debugging - class << self - sig { params(value: T::Boolean).returns(T::Boolean) } - def debug_mode=(value); end - - sig { returns(T::Boolean) } - def debug_mode?; end - - sig { params(object: T.untyped, message: String).void } - def debug_puts(object, message); end - - sig { params(object: T.untyped).returns(String) } - def name_for_debug_caller(object); end - end -end - -module Parlour::Debugging::Tree - class << self - sig { params(message: String).returns(String) } - def begin(message); end - - sig { params(message: String).returns(String) } - def end(message); end - - sig { params(message: String).returns(String) } - def here(message); end - - def line_prefix; end - def text_prefix; end - end -end - -Parlour::Debugging::Tree::INDENT_SPACES = T.let(T.unsafe(nil), Integer) - -class Parlour::DetachedRbiGenerator < ::Parlour::RbiGenerator - sig { override.returns(T.nilable(Parlour::Plugin)) } - def current_plugin; end - - sig { returns(T.untyped) } - def detached!; end - - sig { override.returns(Parlour::Options) } - def options; end - - sig { override.params(strictness: String).returns(String) } - def rbi(strictness = T.unsafe(nil)); end -end - -class Parlour::DetachedRbsGenerator < ::Parlour::RbsGenerator - sig { override.returns(T.nilable(Parlour::Plugin)) } - def current_plugin; end - - sig { returns(T.untyped) } - def detached!; end - - sig { override.returns(Parlour::Options) } - def options; end - - sig { override.returns(String) } - def rbs; end -end - -class Parlour::Generator - sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void } - def initialize(break_params: T.unsafe(nil), tab_size: T.unsafe(nil), sort_namespaces: T.unsafe(nil)); end - - sig { overridable.returns(T.nilable(Parlour::Plugin)) } - def current_plugin; end - - def current_plugin=(_arg0); end - - sig { overridable.returns(Parlour::Options) } - def options; end -end - -class Parlour::Options - sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void } - def initialize(break_params:, tab_size:, sort_namespaces:); end - - sig { returns(Integer) } - def break_params; end - - sig { params(level: Integer, str: String).returns(String) } - def indented(level, str); end - - sig { returns(T::Boolean) } - def sort_namespaces; end - - sig { returns(Integer) } - def tab_size; end -end - -class Parlour::ParseError < ::StandardError - def initialize(buffer, range); end - - sig { returns(Parser::Source::Buffer) } - def buffer; end - - sig { returns(Parser::Source::Range) } - def range; end -end - -class Parlour::Plugin - abstract! - - sig { params(options: T::Hash[T.untyped, T.untyped]).void } - def initialize(options); end - - sig { abstract.params(root: Parlour::RbiGenerator::Namespace).void } - def generate(root); end - - sig { returns(T.nilable(String)) } - def strictness; end - - def strictness=(_arg0); end - - class << self - sig { params(new_plugin: T.class_of(Parlour::Plugin)).void } - def inherited(new_plugin); end - - sig { returns(T::Hash[String, T.class_of(Parlour::Plugin)]) } - def registered_plugins; end - - sig { params(plugins: T::Array[Parlour::Plugin], generator: Parlour::RbiGenerator, allow_failure: T::Boolean).void } - def run_plugins(plugins, generator, allow_failure: T.unsafe(nil)); end - end -end - -class Parlour::RbiGenerator < ::Parlour::Generator - def initialize(**hash); end - - sig { overridable.params(strictness: String).returns(String) } - def rbi(strictness = T.unsafe(nil)); end - - sig { overridable.returns(Parlour::RbiGenerator::Namespace) } - def root; end -end - -class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject - sig { params(generator: Parlour::Generator, code: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Arbitrary).void)).void } - def initialize(generator, code: T.unsafe(nil), &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(String) } - def code; end - - def code=(_arg0); end - - sig { override.returns(String) } - def describe; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method - sig { params(generator: Parlour::Generator, name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).void } - def initialize(generator, name, kind, type, class_attribute: T.unsafe(nil), &block); end - - sig { override.params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(T::Boolean) } - def class_attribute; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { returns(Symbol) } - def kind; end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end - - private - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_definition(indent_level, options); end -end - -class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace - sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void } - def initialize(generator, name, final, sealed, superclass, abstract, &block); end - - sig { returns(T::Boolean) } - def abstract; end - - sig { override.returns(String) } - def describe; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.nilable(String)) } - def superclass; end -end - -class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject - sig { params(generator: Parlour::Generator, name: String, value: T.any(Parlour::Types::Type, String), eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).void } - def initialize(generator, name: T.unsafe(nil), value: T.unsafe(nil), eigen_constant: T.unsafe(nil), &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - def eigen_constant; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def value; end -end - -class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::ClassNamespace - sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, enums: T::Array[T.any(String, [String, String])], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).void } - def initialize(generator, name, final, sealed, enums, abstract, &block); end - - sig { returns(T::Array[T.any(String, [String, String])]) } - def enums; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_body(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject - sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).void } - def initialize(generator, name: T.unsafe(nil), &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject - sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).void } - def initialize(generator, name: T.unsafe(nil), &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject - sig { params(generator: Parlour::Generator, name: String, parameters: T::Array[Parlour::RbiGenerator::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).void } - def initialize(generator, name, parameters, return_type = T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end - - sig { overridable.params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(T::Boolean) } - def abstract; end - - sig { returns(T::Boolean) } - def class_method; end - - sig { override.returns(String) } - def describe; end - - sig { returns(T::Boolean) } - def final; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { returns(T::Boolean) } - def implementation; end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T::Boolean) } - def overridable; end - - sig { returns(T::Boolean) } - def override; end - - sig { returns(T::Array[Parlour::RbiGenerator::Parameter]) } - def parameters; end - - sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) } - def return_type; end - - sig { returns(T::Array[Symbol]) } - def type_parameters; end - - private - - sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_definition(indent_level, options); end - - sig { returns(String) } - def qualifiers; end -end - -class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespace - sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void } - def initialize(generator, name, final, sealed, interface, abstract, &block); end - - sig { returns(T::Boolean) } - def abstract; end - - sig { override.returns(String) } - def describe; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { returns(T::Boolean) } - def interface; end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject - sig { params(generator: Parlour::Generator, name: T.nilable(String), final: T::Boolean, sealed: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Namespace).void)).void } - def initialize(generator, name = T.unsafe(nil), final = T.unsafe(nil), sealed = T.unsafe(nil), &block); end - - sig { params(comment: T.any(String, T::Array[String])).void } - def add_comment_to_next_child(comment); end - - sig { returns(T::Array[Parlour::RbiGenerator::TypeAlias]) } - def aliases; end - - sig { returns(T::Array[Parlour::RbiGenerator::RbiObject]) } - def children; end - - sig { returns(T::Array[Parlour::RbiGenerator::Constant]) } - def constants; end - - def create_arbitrary(code:, &block); end - def create_attr(*args, &blk); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) } - def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) } - def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) } - def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end - - sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) } - def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end - - sig { params(name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ClassNamespace) } - def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end - - sig { params(name: String, value: String, eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).returns(Parlour::RbiGenerator::Constant) } - def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end - - sig { params(name: String, final: T::Boolean, sealed: T::Boolean, enums: T.nilable(T::Array[T.any(String, [String, String])]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).returns(Parlour::RbiGenerator::EnumClassNamespace) } - def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end - - sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).returns(Parlour::RbiGenerator::Extend) } - def create_extend(name, &block); end - - sig { params(extendables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Extend]) } - def create_extends(extendables); end - - sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).returns(Parlour::RbiGenerator::Include) } - def create_include(name, &block); end - - sig { params(includables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Include]) } - def create_includes(includables); end - - sig { params(name: String, parameters: T.nilable(T::Array[Parlour::RbiGenerator::Parameter]), return_type: T.nilable(T.any(Parlour::Types::Type, String)), returns: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).returns(Parlour::RbiGenerator::Method) } - def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end - - sig { params(name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ModuleNamespace) } - def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end - - sig { params(name: String, final: T::Boolean, sealed: T::Boolean, props: T.nilable(T::Array[Parlour::RbiGenerator::StructProp]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).returns(Parlour::RbiGenerator::StructClassNamespace) } - def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).returns(Parlour::RbiGenerator::TypeAlias) } - def create_type_alias(name, type:, &block); end - - sig { override.overridable.returns(String) } - def describe; end - - sig { returns(T::Array[Parlour::RbiGenerator::Extend]) } - def extends; end - - sig { returns(T::Boolean) } - def final; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { returns(T::Array[Parlour::RbiGenerator::Include]) } - def includes; end - - sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { params(constant: Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void } - def path(constant, &block); end - - sig { returns(T::Boolean) } - def sealed; end - - def type_aliases(*args, &blk); end - - private - - sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_body(indent_level, options); end - - sig { params(object: Parlour::RbiGenerator::RbiObject).void } - def move_next_comments(object); end -end - -Parlour::RbiGenerator::Options = Parlour::Options - -class Parlour::RbiGenerator::Parameter - sig { params(name: String, type: T.nilable(T.any(Parlour::Types::Type, String)), default: T.nilable(String)).void } - def initialize(name, type: T.unsafe(nil), default: T.unsafe(nil)); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(T.nilable(String)) } - def default; end - - sig { void } - def generalize_from_rbi!; end - - sig { returns(Symbol) } - def kind; end - - sig { returns(String) } - def name; end - - sig { returns(String) } - def name_without_kind; end - - sig { returns(String) } - def to_def_param; end - - sig { returns(String) } - def to_sig_param; end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -Parlour::RbiGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash) - -class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject - abstract! - - sig { params(generator: Parlour::Generator, name: String).void } - def initialize(generator, name); end - - sig { override.overridable.returns(String) } - def describe; end - - sig { abstract.void } - def generalize_from_rbi!; end - - sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { returns(Parlour::Generator) } - def generator; end - - sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::ClassNamespace - sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, props: T::Array[Parlour::RbiGenerator::StructProp], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).void } - def initialize(generator, name, final, sealed, props, abstract, &block); end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_body(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T::Array[Parlour::RbiGenerator::StructProp]) } - def props; end -end - -class Parlour::RbiGenerator::StructProp - sig { params(name: String, type: T.any(Parlour::Types::Type, String), optional: T.nilable(T.any(Symbol, T::Boolean)), enum: T.nilable(String), dont_store: T.nilable(T::Boolean), foreign: T.nilable(String), default: T.nilable(String), factory: T.nilable(String), immutable: T.nilable(T::Boolean), array: T.nilable(String), override: T.nilable(T::Boolean), redaction: T.nilable(String)).void } - def initialize(name, type, optional: T.unsafe(nil), enum: T.unsafe(nil), dont_store: T.unsafe(nil), foreign: T.unsafe(nil), default: T.unsafe(nil), factory: T.unsafe(nil), immutable: T.unsafe(nil), array: T.unsafe(nil), override: T.unsafe(nil), redaction: T.unsafe(nil)); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(T.nilable(String)) } - def array; end - - sig { returns(T.nilable(String)) } - def default; end - - sig { returns(T.nilable(T::Boolean)) } - def dont_store; end - - sig { returns(T.nilable(String)) } - def enum; end - - sig { returns(T.nilable(String)) } - def factory; end - - sig { returns(T.nilable(String)) } - def foreign; end - - sig { void } - def generalize_from_rbi!; end - - sig { returns(T.nilable(T::Boolean)) } - def immutable; end - - sig { returns(String) } - def name; end - - sig { returns(T.nilable(T.any(Symbol, T::Boolean))) } - def optional; end - - sig { returns(T.nilable(T::Boolean)) } - def override; end - - sig { returns(T.nilable(String)) } - def redaction; end - - sig { returns(String) } - def to_prop_call; end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -Parlour::RbiGenerator::StructProp::EXTRA_PROPERTIES = T.let(T.unsafe(nil), Array) - -class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject - sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).void } - def initialize(generator, name:, type:, &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.void } - def generalize_from_rbi!; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbi(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -class Parlour::RbsGenerator < ::Parlour::Generator - def initialize(**hash); end - - sig { overridable.returns(String) } - def rbs; end - - sig { overridable.returns(Parlour::RbsGenerator::Namespace) } - def root; end -end - -class Parlour::RbsGenerator::Arbitrary < ::Parlour::RbsGenerator::RbsObject - sig { params(generator: Parlour::Generator, code: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Arbitrary).void)).void } - def initialize(generator, code: T.unsafe(nil), &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(String) } - def code; end - - def code=(_arg0); end - - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbsGenerator::Attribute < ::Parlour::RbsGenerator::Method - sig { params(generator: Parlour::Generator, name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).void } - def initialize(generator, name, kind, type, &block); end - - sig { override.params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { returns(Symbol) } - def kind; end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -class Parlour::RbsGenerator::Block - sig { params(type: Parlour::Types::Proc, required: T::Boolean).void } - def initialize(type, required); end - - sig { overridable.params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { params(options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(options); end - - sig { returns(T::Boolean) } - def required; end - - sig { returns(Parlour::Types::Proc) } - def type; end -end - -class Parlour::RbsGenerator::ClassNamespace < ::Parlour::RbsGenerator::Namespace - sig { params(generator: Parlour::Generator, name: String, superclass: T.nilable(T.any(Parlour::Types::Type, String)), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)).void } - def initialize(generator, name, superclass, &block); end - - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) } - def superclass; end -end - -class Parlour::RbsGenerator::Constant < ::Parlour::RbsGenerator::RbsObject - sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Constant).void)).void } - def initialize(generator, name, type:, &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -class Parlour::RbsGenerator::Extend < ::Parlour::RbsGenerator::RbsObject - sig { params(generator: Parlour::Generator, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Extend).void)).void } - def initialize(generator, type:, &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -class Parlour::RbsGenerator::Include < ::Parlour::RbsGenerator::RbsObject - sig { params(generator: Parlour::Generator, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Include).void)).void } - def initialize(generator, type:, &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -class Parlour::RbsGenerator::InterfaceNamespace < ::Parlour::RbsGenerator::Namespace - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end -end - -class Parlour::RbsGenerator::Method < ::Parlour::RbsGenerator::RbsObject - sig { params(generator: Parlour::Generator, name: String, signatures: T::Array[Parlour::RbsGenerator::MethodSignature], class_method: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Method).void)).void } - def initialize(generator, name, signatures, class_method: T.unsafe(nil), &block); end - - sig { overridable.params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(T::Boolean) } - def class_method; end - - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T::Array[Parlour::RbsGenerator::MethodSignature]) } - def signatures; end -end - -class Parlour::RbsGenerator::MethodSignature - sig { params(parameters: T::Array[Parlour::RbsGenerator::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String)), block: T.nilable(Parlour::RbsGenerator::Block), type_parameters: T.nilable(T::Array[Symbol])).void } - def initialize(parameters, return_type = T.unsafe(nil), block: T.unsafe(nil), type_parameters: T.unsafe(nil)); end - - sig { overridable.params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(T.nilable(Parlour::RbsGenerator::Block)) } - def block; end - - sig { params(options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(options); end - - sig { returns(T::Array[Parlour::RbsGenerator::Parameter]) } - def parameters; end - - sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) } - def return_type; end - - sig { returns(T::Array[Symbol]) } - def type_parameters; end -end - -class Parlour::RbsGenerator::ModuleNamespace < ::Parlour::RbsGenerator::Namespace - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end -end - -class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject - sig { params(generator: Parlour::Generator, name: T.nilable(String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).void } - def initialize(generator, name = T.unsafe(nil), &block); end - - sig { params(comment: T.any(String, T::Array[String])).void } - def add_comment_to_next_child(comment); end - - sig { returns(T::Array[Parlour::RbsGenerator::TypeAlias]) } - def aliases; end - - sig { returns(T::Array[Parlour::RbsGenerator::RbsObject]) } - def children; end - - sig { returns(T::Array[Parlour::RbsGenerator::Constant]) } - def constants; end - - def create_arbitrary(code:, &block); end - def create_attr(*args, &blk); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) } - def create_attr_accessor(name, type:, &block); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) } - def create_attr_reader(name, type:, &block); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) } - def create_attr_writer(name, type:, &block); end - - sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) } - def create_attribute(name, kind:, type:, &block); end - - sig { params(name: String, superclass: T.nilable(T.any(Parlour::Types::Type, String)), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)).returns(Parlour::RbsGenerator::ClassNamespace) } - def create_class(name, superclass: T.unsafe(nil), &block); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Constant).void)).returns(Parlour::RbsGenerator::Constant) } - def create_constant(name, type:, &block); end - - sig { params(type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Extend).void)).returns(Parlour::RbsGenerator::Extend) } - def create_extend(type, &block); end - - sig { params(extendables: T::Array[T.any(Parlour::Types::Type, String)]).returns(T::Array[Parlour::RbsGenerator::Extend]) } - def create_extends(extendables); end - - sig { params(type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Include).void)).returns(Parlour::RbsGenerator::Include) } - def create_include(type, &block); end - - sig { params(includables: T::Array[T.any(Parlour::Types::Type, String)]).returns(T::Array[Parlour::RbsGenerator::Include]) } - def create_includes(includables); end - - sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).returns(Parlour::RbsGenerator::InterfaceNamespace) } - def create_interface(name, &block); end - - sig { params(name: String, signatures: T.nilable(T::Array[Parlour::RbsGenerator::MethodSignature]), class_method: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Method).void)).returns(Parlour::RbsGenerator::Method) } - def create_method(name, signatures = T.unsafe(nil), class_method: T.unsafe(nil), &block); end - - sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).returns(Parlour::RbsGenerator::ModuleNamespace) } - def create_module(name, &block); end - - sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::TypeAlias).void)).returns(Parlour::RbsGenerator::TypeAlias) } - def create_type_alias(name, type:, &block); end - - sig { override.overridable.returns(String) } - def describe; end - - sig { returns(T::Array[Parlour::RbsGenerator::Extend]) } - def extends; end - - sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { returns(T::Array[Parlour::RbsGenerator::Include]) } - def includes; end - - sig { override.overridable.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.overridable.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { params(object: T.untyped, block: T.proc.params(x: Parlour::RbsGenerator::Namespace).void).void } - def path(object, &block); end - - def type_aliases(*args, &blk); end - - private - - sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_body(indent_level, options); end - - sig { params(object: Parlour::RbsGenerator::RbsObject).void } - def move_next_comments(object); end -end - -class Parlour::RbsGenerator::Parameter - sig { params(name: String, type: T.nilable(T.any(Parlour::Types::Type, String)), required: T::Boolean).void } - def initialize(name, type: T.unsafe(nil), required: T.unsafe(nil)); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(Symbol) } - def kind; end - - sig { returns(String) } - def name; end - - sig { returns(String) } - def name_without_kind; end - - sig { returns(T::Boolean) } - def required; end - - sig { returns(String) } - def to_rbs_param; end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -Parlour::RbsGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash) -Parlour::RbsGenerator::Parameter::RBS_KEYWORDS = T.let(T.unsafe(nil), Array) - -class Parlour::RbsGenerator::RbsObject < ::Parlour::TypedObject - abstract! - - sig { params(generator: Parlour::Generator, name: String).void } - def initialize(generator, name); end - - sig { override.overridable.returns(String) } - def describe; end - - sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { returns(Parlour::Generator) } - def generator; end - - sig { abstract.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { abstract.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end -end - -class Parlour::RbsGenerator::TypeAlias < ::Parlour::RbsGenerator::RbsObject - sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::TypeAlias).void)).void } - def initialize(generator, name:, type:, &block); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_rbs(indent_level, options); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void } - def merge_into_self(others); end - - sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } - def mergeable?(others); end - - sig { returns(T.any(Parlour::Types::Type, String)) } - def type; end -end - -module Parlour::TypeLoader - class << self - sig { params(filename: String, generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) } - def load_file(filename, generator: T.unsafe(nil)); end - - sig { params(root: String, inclusions: T::Array[String], exclusions: T::Array[String], generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) } - def load_project(root, inclusions: T.unsafe(nil), exclusions: T.unsafe(nil), generator: T.unsafe(nil)); end - - sig { params(source: String, filename: T.nilable(String), generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) } - def load_source(source, filename = T.unsafe(nil), generator: T.unsafe(nil)); end - end -end - -class Parlour::TypeParser - sig { params(ast: Parser::AST::Node, unknown_node_errors: T::Boolean, generator: T.nilable(Parlour::RbiGenerator)).void } - def initialize(ast, unknown_node_errors: T.unsafe(nil), generator: T.unsafe(nil)); end - - sig { returns(Parser::AST::Node) } - def ast; end - - def ast=(_arg0); end - - sig { returns(Parlour::RbiGenerator) } - def generator; end - - def generator=(_arg0); end - - sig { returns(Parlour::RbiGenerator::Namespace) } - def parse_all; end - - sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::Method]) } - def parse_method_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end - - sig { params(node: Parser::AST::Node).returns(Parlour::Types::Type) } - def parse_node_to_type(node); end - - sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::RbiObject]) } - def parse_path_to_object(path, is_within_eigenclass: T.unsafe(nil)); end - - sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::Method]) } - def parse_sig_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end - - sig { params(path: Parlour::TypeParser::NodePath).returns(Parlour::TypeParser::IntermediateSig) } - def parse_sig_into_sig(path); end - - sig { returns(T::Boolean) } - def unknown_node_errors; end - - protected - - sig { params(node: T.nilable(Parser::AST::Node), modifier: Symbol).returns(T::Boolean) } - def body_has_modifier?(node, modifier); end - - sig { params(node: Parser::AST::Node).returns([T::Array[String], T::Array[String]]) } - def body_includes_and_extends(node); end - - sig { params(node: T.nilable(Parser::AST::Node)).returns(T::Array[Symbol]) } - def constant_names(node); end - - sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) } - def node_to_s(node); end - - sig { params(desc: String, node: T.any(Parlour::TypeParser::NodePath, Parser::AST::Node)).returns(T.noreturn) } - def parse_err(desc, node); end - - sig { params(path: Parlour::TypeParser::NodePath).returns(T::Boolean) } - def previous_sibling_sig_node?(path); end - - sig { params(node: Parser::AST::Node).returns(T::Boolean) } - def sig_node?(node); end - - sig { params(msg: String, node: Parser::AST::Node).void } - def warning(msg, node); end - - sig { type_parameters(:A, :B).params(a: T::Array[T.type_parameter(:A)], fa: T.proc.params(item: T.type_parameter(:A)).returns(T.untyped), b: T::Array[T.type_parameter(:B)], fb: T.proc.params(item: T.type_parameter(:B)).returns(T.untyped)).returns(T::Array[[T.type_parameter(:A), T.type_parameter(:B)]]) } - def zip_by(a, fa, b, fb); end - - class << self - sig { params(filename: String, source: String, generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::TypeParser) } - def from_source(filename, source, generator: T.unsafe(nil)); end - - sig { params(str: String).returns(Parlour::Types::Type) } - def parse_single_type(str); end - end -end - -class Parlour::TypeParser::IntermediateSig < ::T::Struct - prop :abstract, T::Boolean - prop :final, T::Boolean - prop :overridable, T::Boolean - prop :override, T::Boolean - prop :params, T.nilable(T::Array[Parser::AST::Node]) - prop :return_type, T.nilable(String) - prop :type_parameters, T.nilable(T::Array[Symbol]) - - class << self - def inherited(s); end - end -end - -class Parlour::TypeParser::NodePath - sig { params(indices: T::Array[Integer]).void } - def initialize(indices); end - - sig { params(index: Integer).returns(Parlour::TypeParser::NodePath) } - def child(index); end - - sig { returns(T::Array[Integer]) } - def indices; end - - sig { returns(Parlour::TypeParser::NodePath) } - def parent; end - - sig { params(offset: Integer).returns(Parlour::TypeParser::NodePath) } - def sibling(offset); end - - sig { params(start: Parser::AST::Node).returns(Parser::AST::Node) } - def traverse(start); end -end - -class Parlour::TypedObject - abstract! - - sig { params(name: String).void } - def initialize(name); end - - sig { params(comment: T.any(String, T::Array[String])).void } - def add_comment(comment); end - - def add_comments(*args, &blk); end - - sig { returns(T::Array[String]) } - def comments; end - - sig { abstract.returns(String) } - def describe; end - - sig { returns(T.nilable(Parlour::Plugin)) } - def generated_by; end - - sig { returns(String) } - def name; end - - protected - - sig { params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) } - def generate_comments(indent_level, options); end -end - -module Parlour::Types; end - -class Parlour::Types::Array < ::Parlour::Types::SingleElementCollection - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def collection_name; end -end - -class Parlour::Types::Boolean < ::Parlour::Types::Type - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end -end - -class Parlour::Types::Class < ::Parlour::Types::Type - sig { params(type: T.any(Parlour::Types::Type, String)).void } - def initialize(type); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(Parlour::Types::Type) } - def type; end -end - -class Parlour::Types::Enumerable < ::Parlour::Types::SingleElementCollection - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def collection_name; end -end - -class Parlour::Types::Enumerator < ::Parlour::Types::SingleElementCollection - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def collection_name; end -end - -class Parlour::Types::Generic < ::Parlour::Types::Type - sig { params(type: T.any(Parlour::Types::Type, String), type_params: T::Array[T.any(Parlour::Types::Type, String)]).void } - def initialize(type, type_params); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(Parlour::Types::Type) } - def type; end - - sig { returns(T::Array[Parlour::Types::Type]) } - def type_params; end -end - -class Parlour::Types::Hash < ::Parlour::Types::Type - sig { params(key: T.any(Parlour::Types::Type, String), value: T.any(Parlour::Types::Type, String)).void } - def initialize(key, value); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(Parlour::Types::Type) } - def key; end - - sig { returns(Parlour::Types::Type) } - def value; end -end - -class Parlour::Types::Intersection < ::Parlour::Types::Type - sig { params(types: T::Array[T.any(Parlour::Types::Type, String)]).void } - def initialize(types); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(T::Array[Parlour::Types::Type]) } - def types; end -end - -class Parlour::Types::Nilable < ::Parlour::Types::Type - sig { params(type: T.any(Parlour::Types::Type, String)).void } - def initialize(type); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(Parlour::Types::Type) } - def type; end -end - -class Parlour::Types::Proc < ::Parlour::Types::Type - sig { params(parameters: T::Array[Parlour::Types::Proc::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String))).void } - def initialize(parameters, return_type); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(T::Array[Parlour::Types::Proc::Parameter]) } - def parameters; end - - sig { returns(T.nilable(Parlour::Types::Type)) } - def return_type; end -end - -class Parlour::Types::Proc::Parameter - sig { params(name: String, type: T.any(Parlour::Types::Type, String), default: T.nilable(String)).void } - def initialize(name, type, default = T.unsafe(nil)); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { returns(T.nilable(String)) } - def default; end - - sig { returns(String) } - def name; end - - sig { returns(Parlour::Types::Type) } - def type; end -end - -class Parlour::Types::Range < ::Parlour::Types::SingleElementCollection - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def collection_name; end -end - -class Parlour::Types::Raw < ::Parlour::Types::Type - sig { params(str: String).void } - def initialize(str); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(String) } - def str; end -end - -class Parlour::Types::Record < ::Parlour::Types::Type - sig { params(keys_to_types: T::Hash[Symbol, T.any(Parlour::Types::Type, String)]).void } - def initialize(keys_to_types); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(T::Hash[Symbol, Parlour::Types::Type]) } - def keys_to_types; end -end - -class Parlour::Types::Self < ::Parlour::Types::Type - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end -end - -class Parlour::Types::Set < ::Parlour::Types::SingleElementCollection - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def collection_name; end -end - -class Parlour::Types::SingleElementCollection < ::Parlour::Types::Type - abstract! - - sig { params(element: T.any(Parlour::Types::Type, String)).void } - def initialize(element); end - - sig { abstract.returns(String) } - def collection_name; end - - sig { override.returns(String) } - def describe; end - - sig { returns(Parlour::Types::Type) } - def element; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end -end - -class Parlour::Types::Tuple < ::Parlour::Types::Type - sig { params(types: T::Array[T.any(Parlour::Types::Type, String)]).void } - def initialize(types); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(T::Array[Parlour::Types::Type]) } - def types; end -end - -class Parlour::Types::Type - abstract! - - def initialize(*args, &blk); end - - sig { abstract.returns(String) } - def describe; end - - sig { abstract.returns(String) } - def generate_rbi; end - - sig { abstract.returns(String) } - def generate_rbs; end - - def hash; end - - sig { params(type_like: T.any(Parlour::Types::Type, String)).returns(Parlour::Types::Type) } - def to_type(type_like); end - - class << self - sig { params(type_like: T.any(Parlour::Types::Type, String)).returns(Parlour::Types::Type) } - def to_type(type_like); end - end -end - -Parlour::Types::TypeLike = T.type_alias { T.any(Parlour::Types::Type, String) } - -class Parlour::Types::Union < ::Parlour::Types::Type - sig { params(types: T::Array[T.any(Parlour::Types::Type, String)]).void } - def initialize(types); end - - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end - - sig { returns(T::Array[Parlour::Types::Type]) } - def types; end -end - -class Parlour::Types::Untyped < ::Parlour::Types::Type - sig { params(other: Object).returns(T::Boolean) } - def ==(other); end - - sig { override.returns(String) } - def describe; end - - sig { override.returns(String) } - def generate_rbi; end - - sig { override.returns(String) } - def generate_rbs; end -end - -Parlour::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@7.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@7.0.0.rbi new file mode 100644 index 0000000000..32d824cebe --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/parlour@7.0.0.rbi @@ -0,0 +1,2154 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `parlour` gem. +# Please instead update this file by running `bin/tapioca gem parlour`. + +module Kernel + extend ::Forwardable +end + +module Parlour; end + +class Parlour::ConflictResolver + def initialize; end + + sig do + params( + namespace: Parlour::RbiGenerator::Namespace, + resolver: T.proc.params(desc: ::String, choices: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T.nilable(::Parlour::RbiGenerator::RbiObject)) + ).void + end + def resolve_conflicts(namespace, &resolver); end + + private + + sig { params(arr: T::Array[T.untyped]).returns(T::Boolean) } + def all_eql?(arr); end + + sig { params(namespace: Parlour::RbiGenerator::Namespace, name: T.nilable(::String)).void } + def deduplicate_mixins_of_name(namespace, name); end + + sig { params(arr: T::Array[T.untyped]).returns(T.nilable(::Symbol)) } + def merge_strategy(arr); end +end + +module Parlour::Conversion; end + +class Parlour::Conversion::Converter + abstract! + + def initialize; end + + sig { params(msg: ::String, node: ::Parlour::RbiGenerator::RbiObject).void } + def add_warning(msg, node); end + + sig { returns(T::Array[[::String, ::Parlour::TypedObject]]) } + def warnings; end +end + +class Parlour::Conversion::RbiToRbs < ::Parlour::Conversion::Converter + sig { params(rbs_gen: ::Parlour::RbsGenerator).void } + def initialize(rbs_gen); end + + sig { params(from: Parlour::RbiGenerator::Namespace, to: Parlour::RbsGenerator::Namespace).void } + def convert_all(from, to); end + + sig { params(node: ::Parlour::RbiGenerator::RbiObject, new_parent: Parlour::RbsGenerator::Namespace).void } + def convert_object(node, new_parent); end + + sig { returns(::Parlour::RbsGenerator) } + def rbs_gen; end +end + +module Parlour::Debugging + class << self + sig { params(value: T::Boolean).returns(T::Boolean) } + def debug_mode=(value); end + + sig { returns(T::Boolean) } + def debug_mode?; end + + sig { params(object: T.untyped, message: ::String).void } + def debug_puts(object, message); end + + sig { params(object: T.untyped).returns(::String) } + def name_for_debug_caller(object); end + end +end + +class Parlour::Debugging::Tree + sig { params(colour: T::Boolean).void } + def initialize(colour: T.unsafe(nil)); end + + sig { params(message: ::String).returns(::String) } + def begin(message); end + + sig { returns(T::Boolean) } + def colour; end + + sig { params(message: ::String).returns(::String) } + def end(message); end + + sig { params(message: ::String).returns(::String) } + def here(message); end + + def indent!(offset); end + def line_prefix; end + def text_prefix; end +end + +Parlour::Debugging::Tree::INDENT_SPACES = T.let(T.unsafe(nil), Integer) + +class Parlour::DetachedRbiGenerator < ::Parlour::RbiGenerator + sig { override.returns(T.nilable(::Parlour::Plugin)) } + def current_plugin; end + + sig { returns(T.untyped) } + def detached!; end + + sig { override.returns(::Parlour::Options) } + def options; end + + sig { override.params(strictness: ::String).returns(::String) } + def rbi(strictness = T.unsafe(nil)); end +end + +class Parlour::DetachedRbsGenerator < ::Parlour::RbsGenerator + sig { override.returns(T.nilable(::Parlour::Plugin)) } + def current_plugin; end + + sig { returns(T.untyped) } + def detached!; end + + sig { override.returns(::Parlour::Options) } + def options; end + + sig { override.returns(::String) } + def rbs; end +end + +class Parlour::Generator + sig { params(break_params: ::Integer, tab_size: ::Integer, sort_namespaces: T::Boolean).void } + def initialize(break_params: T.unsafe(nil), tab_size: T.unsafe(nil), sort_namespaces: T.unsafe(nil)); end + + sig { overridable.returns(T.nilable(::Parlour::Plugin)) } + def current_plugin; end + + def current_plugin=(_arg0); end + + sig { overridable.returns(::Parlour::Options) } + def options; end +end + +module Parlour::Mixin; end + +module Parlour::Mixin::Searchable + extend T::Generic + + abstract! + + Child = type_member + + sig { abstract.returns(T::Array[Child]) } + def children; end + + sig { params(name: T.nilable(::String), type: T.nilable(::Class)).returns(Child) } + def find(name: T.unsafe(nil), type: T.unsafe(nil)); end + + sig { params(name: T.nilable(::String), type: T.nilable(::Class)).returns(T::Array[Child]) } + def find_all(name: T.unsafe(nil), type: T.unsafe(nil)); end + + private + + sig { params(child: Child, name: T.nilable(::String), type: T.nilable(::Class)).returns(T::Boolean) } + def searchable_child_matches(child, name, type); end +end + +class Parlour::Options + sig { params(break_params: ::Integer, tab_size: ::Integer, sort_namespaces: T::Boolean).void } + def initialize(break_params:, tab_size:, sort_namespaces:); end + + sig { returns(::Integer) } + def break_params; end + + sig { params(level: ::Integer, str: ::String).returns(::String) } + def indented(level, str); end + + sig { returns(T::Boolean) } + def sort_namespaces; end + + sig { returns(::Integer) } + def tab_size; end +end + +class Parlour::ParseError < ::StandardError + def initialize(buffer, range); end + + sig { returns(::Parser::Source::Buffer) } + def buffer; end + + sig { returns(::Parser::Source::Range) } + def range; end +end + +class Parlour::Plugin + abstract! + + sig { params(options: T::Hash[T.untyped, T.untyped]).void } + def initialize(options); end + + sig { abstract.params(root: Parlour::RbiGenerator::Namespace).void } + def generate(root); end + + sig { returns(T.nilable(::String)) } + def strictness; end + + def strictness=(_arg0); end + + class << self + sig { params(new_plugin: T.class_of(Parlour::Plugin)).void } + def inherited(new_plugin); end + + sig { returns(T::Hash[::String, T.class_of(Parlour::Plugin)]) } + def registered_plugins; end + + sig do + params( + plugins: T::Array[::Parlour::Plugin], + generator: ::Parlour::RbiGenerator, + allow_failure: T::Boolean + ).void + end + def run_plugins(plugins, generator, allow_failure: T.unsafe(nil)); end + end +end + +class Parlour::RbiGenerator < ::Parlour::Generator + def initialize(**hash); end + + sig { overridable.params(strictness: ::String).returns(::String) } + def rbi(strictness = T.unsafe(nil)); end + + sig { overridable.returns(Parlour::RbiGenerator::Namespace) } + def root; end +end + +class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject + sig do + params( + generator: ::Parlour::Generator, + code: ::String, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Arbitrary).void) + ).void + end + def initialize(generator, code: T.unsafe(nil), &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(::String) } + def code; end + + def code=(_arg0); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + kind: ::Symbol, + type: T.any(::Parlour::Types::Type, ::String), + class_attribute: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void) + ).void + end + def initialize(generator, name, kind, type, class_attribute: T.unsafe(nil), &block); end + + sig { override.params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(T::Boolean) } + def class_attribute; end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { returns(::Symbol) } + def kind; end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end + + private + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_definition(indent_level, options); end +end + +class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace + extend T::Generic + + Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } } + + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + superclass: T.nilable(::String), + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void) + ).void + end + def initialize(generator, name, final, sealed, superclass, abstract, &block); end + + sig { returns(T::Boolean) } + def abstract; end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.nilable(::String)) } + def superclass; end +end + +class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + value: T.any(::Parlour::Types::Type, ::String), + eigen_constant: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Constant).void) + ).void + end + def initialize(generator, name: T.unsafe(nil), value: T.unsafe(nil), eigen_constant: T.unsafe(nil), &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + def eigen_constant; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def value; end +end + +class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::ClassNamespace + extend T::Generic + + Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } } + + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + enums: T::Array[T.any(::String, [::String, ::String])], + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void) + ).void + end + def initialize(generator, name, final, sealed, enums, abstract, &block); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { returns(T::Array[T.any(::String, [::String, ::String])]) } + def enums; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_body(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Extend).void) + ).void + end + def initialize(generator, name: T.unsafe(nil), &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Include).void) + ).void + end + def initialize(generator, name: T.unsafe(nil), &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + parameters: T::Array[::Parlour::RbiGenerator::Parameter], + return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)), + abstract: T::Boolean, + implementation: T::Boolean, + override: T::Boolean, + overridable: T::Boolean, + class_method: T::Boolean, + final: T::Boolean, + type_parameters: T.nilable(T::Array[::Symbol]), + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Method).void) + ).void + end + def initialize(generator, name, parameters, return_type = T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end + + sig { overridable.params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(T::Boolean) } + def abstract; end + + sig { returns(T::Boolean) } + def class_method; end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { returns(T::Boolean) } + def final; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { returns(T::Boolean) } + def implementation; end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T::Boolean) } + def overridable; end + + sig { returns(T::Boolean) } + def override; end + + sig { returns(T::Array[::Parlour::RbiGenerator::Parameter]) } + def parameters; end + + sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) } + def return_type; end + + sig { returns(T::Array[::Symbol]) } + def type_parameters; end + + private + + sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_definition(indent_level, options); end + + sig { returns(::String) } + def qualifiers; end +end + +class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespace + extend T::Generic + + Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } } + + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + interface: T::Boolean, + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void) + ).void + end + def initialize(generator, name, final, sealed, interface, abstract, &block); end + + sig { returns(T::Boolean) } + def abstract; end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { returns(T::Boolean) } + def interface; end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject + extend T::Generic + include ::Parlour::Mixin::Searchable + + Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } } + + sig do + params( + generator: ::Parlour::Generator, + name: T.nilable(::String), + final: T::Boolean, + sealed: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Namespace).void) + ).void + end + def initialize(generator, name = T.unsafe(nil), final = T.unsafe(nil), sealed = T.unsafe(nil), &block); end + + sig { params(comment: T.any(::String, T::Array[::String])).void } + def add_comment_to_next_child(comment); end + + sig { returns(T::Array[::Parlour::RbiGenerator::TypeAlias]) } + def aliases; end + + sig { override.returns(T::Array[::Parlour::RbiGenerator::RbiObject]) } + def children; end + + sig { returns(T::Array[::Parlour::RbiGenerator::Constant]) } + def constants; end + + def create_arbitrary(code:, &block); end + def create_attr(*args, &blk); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + class_attribute: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void) + ).returns(::Parlour::RbiGenerator::Attribute) + end + def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + class_attribute: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void) + ).returns(::Parlour::RbiGenerator::Attribute) + end + def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + class_attribute: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void) + ).returns(::Parlour::RbiGenerator::Attribute) + end + def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + kind: ::Symbol, + type: T.any(::Parlour::Types::Type, ::String), + class_attribute: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void) + ).returns(::Parlour::RbiGenerator::Attribute) + end + def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + superclass: T.nilable(::String), + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void) + ).returns(Parlour::RbiGenerator::ClassNamespace) + end + def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + value: ::String, + eigen_constant: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Constant).void) + ).returns(::Parlour::RbiGenerator::Constant) + end + def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + enums: T.nilable(T::Array[T.any(::String, [::String, ::String])]), + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void) + ).returns(Parlour::RbiGenerator::EnumClassNamespace) + end + def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Extend).void) + ).returns(::Parlour::RbiGenerator::Extend) + end + def create_extend(name, &block); end + + sig { params(extendables: T::Array[::String]).returns(T::Array[::Parlour::RbiGenerator::Extend]) } + def create_extends(extendables); end + + sig do + params( + name: ::String, + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Include).void) + ).returns(::Parlour::RbiGenerator::Include) + end + def create_include(name, &block); end + + sig { params(includables: T::Array[::String]).returns(T::Array[::Parlour::RbiGenerator::Include]) } + def create_includes(includables); end + + sig do + params( + name: ::String, + parameters: T.nilable(T::Array[::Parlour::RbiGenerator::Parameter]), + return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)), + returns: T.nilable(T.any(::Parlour::Types::Type, ::String)), + abstract: T::Boolean, + implementation: T::Boolean, + override: T::Boolean, + overridable: T::Boolean, + class_method: T::Boolean, + final: T::Boolean, + type_parameters: T.nilable(T::Array[::Symbol]), + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Method).void) + ).returns(::Parlour::RbiGenerator::Method) + end + def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + interface: T::Boolean, + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void) + ).returns(Parlour::RbiGenerator::ModuleNamespace) + end + def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + props: T.nilable(T::Array[::Parlour::RbiGenerator::StructProp]), + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void) + ).returns(Parlour::RbiGenerator::StructClassNamespace) + end + def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::TypeAlias).void) + ).returns(::Parlour::RbiGenerator::TypeAlias) + end + def create_type_alias(name, type:, &block); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { returns(T::Array[::Parlour::RbiGenerator::Extend]) } + def extends; end + + sig { returns(T::Boolean) } + def final; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { returns(T::Array[::Parlour::RbiGenerator::Include]) } + def includes; end + + sig { override.overridable.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.overridable.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { params(constant: ::Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void } + def path(constant, &block); end + + sig { returns(T::Boolean) } + def sealed; end + + def type_aliases(*args, &blk); end + + private + + sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_body(indent_level, options); end + + sig { params(object: ::Parlour::RbiGenerator::RbiObject).void } + def move_next_comments(object); end +end + +Parlour::RbiGenerator::Options = Parlour::Options + +class Parlour::RbiGenerator::Parameter + sig do + params( + name: ::String, + type: T.nilable(T.any(::Parlour::Types::Type, ::String)), + default: T.nilable(::String) + ).void + end + def initialize(name, type: T.unsafe(nil), default: T.unsafe(nil)); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(T.nilable(::String)) } + def default; end + + sig { returns(::String) } + def describe_in_method; end + + sig { void } + def generalize_from_rbi!; end + + sig { returns(::Symbol) } + def kind; end + + sig { returns(::String) } + def name; end + + sig { returns(::String) } + def name_without_kind; end + + sig { returns(::String) } + def to_def_param; end + + sig { returns(::String) } + def to_sig_param; end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +Parlour::RbiGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash) + +class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject + abstract! + + sig { params(generator: ::Parlour::Generator, name: ::String).void } + def initialize(generator, name); end + + sig { abstract.void } + def generalize_from_rbi!; end + + sig { abstract.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { returns(::Parlour::Generator) } + def generator; end + + sig { abstract.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { abstract.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::ClassNamespace + extend T::Generic + + Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } } + + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + final: T::Boolean, + sealed: T::Boolean, + props: T::Array[::Parlour::RbiGenerator::StructProp], + abstract: T::Boolean, + block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void) + ).void + end + def initialize(generator, name, final, sealed, props, abstract, &block); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_body(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T::Array[::Parlour::RbiGenerator::StructProp]) } + def props; end +end + +class Parlour::RbiGenerator::StructProp + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + optional: T.nilable(T.any(::Symbol, T::Boolean)), + enum: T.nilable(::String), + dont_store: T.nilable(T::Boolean), + foreign: T.nilable(::String), + default: T.nilable(::String), + factory: T.nilable(::String), + immutable: T.nilable(T::Boolean), + array: T.nilable(::String), + override: T.nilable(T::Boolean), + redaction: T.nilable(::String) + ).void + end + def initialize(name, type, optional: T.unsafe(nil), enum: T.unsafe(nil), dont_store: T.unsafe(nil), foreign: T.unsafe(nil), default: T.unsafe(nil), factory: T.unsafe(nil), immutable: T.unsafe(nil), array: T.unsafe(nil), override: T.unsafe(nil), redaction: T.unsafe(nil)); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(T.nilable(::String)) } + def array; end + + sig { returns(T.nilable(::String)) } + def default; end + + sig { returns(T.nilable(T::Boolean)) } + def dont_store; end + + sig { returns(T.nilable(::String)) } + def enum; end + + sig { returns(T.nilable(::String)) } + def factory; end + + sig { returns(T.nilable(::String)) } + def foreign; end + + sig { void } + def generalize_from_rbi!; end + + sig { returns(T.nilable(T::Boolean)) } + def immutable; end + + sig { returns(::String) } + def name; end + + sig { returns(T.nilable(T.any(::Symbol, T::Boolean))) } + def optional; end + + sig { returns(T.nilable(T::Boolean)) } + def override; end + + sig { returns(T.nilable(::String)) } + def redaction; end + + sig { returns(::String) } + def to_prop_call; end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +Parlour::RbiGenerator::StructProp::EXTRA_PROPERTIES = T.let(T.unsafe(nil), Array) + +class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::TypeAlias).void) + ).void + end + def initialize(generator, name:, type:, &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.void } + def generalize_from_rbi!; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbi(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +class Parlour::RbsGenerator < ::Parlour::Generator + def initialize(**hash); end + + sig { overridable.returns(::String) } + def rbs; end + + sig { overridable.returns(Parlour::RbsGenerator::Namespace) } + def root; end +end + +class Parlour::RbsGenerator::Arbitrary < ::Parlour::RbsGenerator::RbsObject + sig do + params( + generator: ::Parlour::Generator, + code: ::String, + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Arbitrary).void) + ).void + end + def initialize(generator, code: T.unsafe(nil), &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(::String) } + def code; end + + def code=(_arg0); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbsGenerator::Attribute < ::Parlour::RbsGenerator::Method + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + kind: ::Symbol, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void) + ).void + end + def initialize(generator, name, kind, type, &block); end + + sig { override.params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { returns(::Symbol) } + def kind; end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +class Parlour::RbsGenerator::Block + sig { params(type: ::Parlour::Types::Proc, required: T::Boolean).void } + def initialize(type, required); end + + sig { overridable.params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { params(options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(options); end + + sig { returns(T::Boolean) } + def required; end + + sig { returns(::Parlour::Types::Proc) } + def type; end +end + +class Parlour::RbsGenerator::ClassNamespace < ::Parlour::RbsGenerator::Namespace + extend T::Generic + + Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } } + + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + superclass: T.nilable(T.any(::Parlour::Types::Type, ::String)), + block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void) + ).void + end + def initialize(generator, name, superclass, &block); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) } + def superclass; end +end + +class Parlour::RbsGenerator::Constant < ::Parlour::RbsGenerator::RbsObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Constant).void) + ).void + end + def initialize(generator, name, type:, &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +class Parlour::RbsGenerator::Extend < ::Parlour::RbsGenerator::RbsObject + sig do + params( + generator: ::Parlour::Generator, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Extend).void) + ).void + end + def initialize(generator, type:, &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +class Parlour::RbsGenerator::Include < ::Parlour::RbsGenerator::RbsObject + sig do + params( + generator: ::Parlour::Generator, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Include).void) + ).void + end + def initialize(generator, type:, &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +class Parlour::RbsGenerator::InterfaceNamespace < ::Parlour::RbsGenerator::Namespace + extend T::Generic + + Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } } + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end +end + +class Parlour::RbsGenerator::Method < ::Parlour::RbsGenerator::RbsObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + signatures: T::Array[::Parlour::RbsGenerator::MethodSignature], + class_method: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Method).void) + ).void + end + def initialize(generator, name, signatures, class_method: T.unsafe(nil), &block); end + + sig { overridable.params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(T::Boolean) } + def class_method; end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T::Array[::Parlour::RbsGenerator::MethodSignature]) } + def signatures; end +end + +class Parlour::RbsGenerator::MethodSignature + sig do + params( + parameters: T::Array[::Parlour::RbsGenerator::Parameter], + return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)), + block: T.nilable(::Parlour::RbsGenerator::Block), + type_parameters: T.nilable(T::Array[::Symbol]) + ).void + end + def initialize(parameters, return_type = T.unsafe(nil), block: T.unsafe(nil), type_parameters: T.unsafe(nil)); end + + sig { overridable.params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(T.nilable(::Parlour::RbsGenerator::Block)) } + def block; end + + sig { returns(::String) } + def describe_in_method; end + + sig { params(options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(options); end + + sig { returns(T::Array[::Parlour::RbsGenerator::Parameter]) } + def parameters; end + + sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) } + def return_type; end + + sig { returns(T::Array[::Symbol]) } + def type_parameters; end +end + +class Parlour::RbsGenerator::ModuleNamespace < ::Parlour::RbsGenerator::Namespace + extend T::Generic + + Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } } + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end +end + +class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject + extend T::Generic + include ::Parlour::Mixin::Searchable + + Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } } + + sig do + params( + generator: ::Parlour::Generator, + name: T.nilable(::String), + block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void) + ).void + end + def initialize(generator, name = T.unsafe(nil), &block); end + + sig { params(comment: T.any(::String, T::Array[::String])).void } + def add_comment_to_next_child(comment); end + + sig { returns(T::Array[::Parlour::RbsGenerator::TypeAlias]) } + def aliases; end + + sig { override.returns(T::Array[::Parlour::RbsGenerator::RbsObject]) } + def children; end + + sig { returns(T::Array[::Parlour::RbsGenerator::Constant]) } + def constants; end + + def create_arbitrary(code:, &block); end + def create_attr(*args, &blk); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void) + ).returns(::Parlour::RbsGenerator::Attribute) + end + def create_attr_accessor(name, type:, &block); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void) + ).returns(::Parlour::RbsGenerator::Attribute) + end + def create_attr_reader(name, type:, &block); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void) + ).returns(::Parlour::RbsGenerator::Attribute) + end + def create_attr_writer(name, type:, &block); end + + sig do + params( + name: ::String, + kind: ::Symbol, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void) + ).returns(::Parlour::RbsGenerator::Attribute) + end + def create_attribute(name, kind:, type:, &block); end + + sig do + params( + name: ::String, + superclass: T.nilable(T.any(::Parlour::Types::Type, ::String)), + block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void) + ).returns(Parlour::RbsGenerator::ClassNamespace) + end + def create_class(name, superclass: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Constant).void) + ).returns(::Parlour::RbsGenerator::Constant) + end + def create_constant(name, type:, &block); end + + sig do + params( + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Extend).void) + ).returns(::Parlour::RbsGenerator::Extend) + end + def create_extend(type, &block); end + + sig do + params( + extendables: T::Array[T.any(::Parlour::Types::Type, ::String)] + ).returns(T::Array[::Parlour::RbsGenerator::Extend]) + end + def create_extends(extendables); end + + sig do + params( + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Include).void) + ).returns(::Parlour::RbsGenerator::Include) + end + def create_include(type, &block); end + + sig do + params( + includables: T::Array[T.any(::Parlour::Types::Type, ::String)] + ).returns(T::Array[::Parlour::RbsGenerator::Include]) + end + def create_includes(includables); end + + sig do + params( + name: ::String, + block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void) + ).returns(Parlour::RbsGenerator::InterfaceNamespace) + end + def create_interface(name, &block); end + + sig do + params( + name: ::String, + signatures: T.nilable(T::Array[::Parlour::RbsGenerator::MethodSignature]), + class_method: T::Boolean, + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Method).void) + ).returns(::Parlour::RbsGenerator::Method) + end + def create_method(name, signatures = T.unsafe(nil), class_method: T.unsafe(nil), &block); end + + sig do + params( + name: ::String, + block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void) + ).returns(Parlour::RbsGenerator::ModuleNamespace) + end + def create_module(name, &block); end + + sig do + params( + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::TypeAlias).void) + ).returns(::Parlour::RbsGenerator::TypeAlias) + end + def create_type_alias(name, type:, &block); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { returns(T::Array[::Parlour::RbsGenerator::Extend]) } + def extends; end + + sig { override.overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { returns(T::Array[::Parlour::RbsGenerator::Include]) } + def includes; end + + sig { override.overridable.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.overridable.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { params(object: T.untyped, block: T.proc.params(x: Parlour::RbsGenerator::Namespace).void).void } + def path(object, &block); end + + def type_aliases(*args, &blk); end + + private + + sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_body(indent_level, options); end + + sig { params(object: ::Parlour::RbsGenerator::RbsObject).void } + def move_next_comments(object); end +end + +class Parlour::RbsGenerator::Parameter + sig { params(name: ::String, type: T.nilable(T.any(::Parlour::Types::Type, ::String)), required: T::Boolean).void } + def initialize(name, type: T.unsafe(nil), required: T.unsafe(nil)); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(::Symbol) } + def kind; end + + sig { returns(::String) } + def name; end + + sig { returns(::String) } + def name_without_kind; end + + sig { returns(T::Boolean) } + def required; end + + sig { returns(::String) } + def to_rbs_param; end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +Parlour::RbsGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash) +Parlour::RbsGenerator::Parameter::RBS_KEYWORDS = T.let(T.unsafe(nil), Array) + +class Parlour::RbsGenerator::RbsObject < ::Parlour::TypedObject + abstract! + + sig { params(generator: ::Parlour::Generator, name: ::String).void } + def initialize(generator, name); end + + sig { abstract.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { returns(::Parlour::Generator) } + def generator; end + + sig { abstract.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { abstract.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end +end + +class Parlour::RbsGenerator::TypeAlias < ::Parlour::RbsGenerator::RbsObject + sig do + params( + generator: ::Parlour::Generator, + name: ::String, + type: T.any(::Parlour::Types::Type, ::String), + block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::TypeAlias).void) + ).void + end + def initialize(generator, name:, type:, &block); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_rbs(indent_level, options); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void } + def merge_into_self(others); end + + sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) } + def mergeable?(others); end + + sig { returns(T.any(::Parlour::Types::Type, ::String)) } + def type; end +end + +module Parlour::TypeLoader + class << self + sig do + params( + filename: ::String, + generator: T.nilable(::Parlour::RbiGenerator) + ).returns(Parlour::RbiGenerator::Namespace) + end + def load_file(filename, generator: T.unsafe(nil)); end + + sig do + params( + root: ::String, + inclusions: T::Array[::String], + exclusions: T::Array[::String], + generator: T.nilable(::Parlour::RbiGenerator) + ).returns(Parlour::RbiGenerator::Namespace) + end + def load_project(root, inclusions: T.unsafe(nil), exclusions: T.unsafe(nil), generator: T.unsafe(nil)); end + + sig do + params( + source: ::String, + filename: T.nilable(::String), + generator: T.nilable(::Parlour::RbiGenerator) + ).returns(Parlour::RbiGenerator::Namespace) + end + def load_source(source, filename = T.unsafe(nil), generator: T.unsafe(nil)); end + end +end + +class Parlour::TypeParser + sig do + params( + ast: ::Parser::AST::Node, + unknown_node_errors: T::Boolean, + generator: T.nilable(::Parlour::RbiGenerator) + ).void + end + def initialize(ast, unknown_node_errors: T.unsafe(nil), generator: T.unsafe(nil)); end + + sig { returns(::Parser::AST::Node) } + def ast; end + + def ast=(_arg0); end + + sig { returns(::Parlour::RbiGenerator) } + def generator; end + + def generator=(_arg0); end + + sig { returns(Parlour::RbiGenerator::Namespace) } + def parse_all; end + + sig do + params( + path: ::Parlour::TypeParser::NodePath, + is_within_eigenclass: T::Boolean + ).returns(T::Array[::Parlour::RbiGenerator::Method]) + end + def parse_method_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end + + sig { params(node: ::Parser::AST::Node).returns(::Parlour::Types::Type) } + def parse_node_to_type(node); end + + sig do + params( + path: ::Parlour::TypeParser::NodePath, + is_within_eigenclass: T::Boolean + ).returns(T::Array[::Parlour::RbiGenerator::RbiObject]) + end + def parse_path_to_object(path, is_within_eigenclass: T.unsafe(nil)); end + + sig do + params( + path: ::Parlour::TypeParser::NodePath, + is_within_eigenclass: T::Boolean + ).returns(T::Array[::Parlour::RbiGenerator::Method]) + end + def parse_sig_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end + + sig { params(path: ::Parlour::TypeParser::NodePath).returns(::Parlour::TypeParser::IntermediateSig) } + def parse_sig_into_sig(path); end + + sig { returns(T::Boolean) } + def unknown_node_errors; end + + protected + + sig { params(node: T.nilable(::Parser::AST::Node), modifier: ::Symbol).returns(T::Boolean) } + def body_has_modifier?(node, modifier); end + + sig { params(node: ::Parser::AST::Node).returns([T::Array[::String], T::Array[::String]]) } + def body_includes_and_extends(node); end + + sig { params(node: T.nilable(::Parser::AST::Node)).returns(T::Array[::Symbol]) } + def constant_names(node); end + + sig { params(node: T.nilable(::Parser::AST::Node)).returns(T.nilable(::String)) } + def node_to_s(node); end + + sig { params(desc: ::String, node: T.any(::Parlour::TypeParser::NodePath, ::Parser::AST::Node)).returns(T.noreturn) } + def parse_err(desc, node); end + + sig { params(path: ::Parlour::TypeParser::NodePath).returns(T::Boolean) } + def previous_sibling_sig_node?(path); end + + sig { params(node: ::Parser::AST::Node).returns(T::Boolean) } + def sig_node?(node); end + + sig { params(msg: ::String, node: ::Parser::AST::Node).void } + def warning(msg, node); end + + sig do + type_parameters(:A, :B) + .params( + a: T::Array[T.type_parameter(:A)], + fa: T.proc.params(item: T.type_parameter(:A)).returns(T.untyped), + b: T::Array[T.type_parameter(:B)], + fb: T.proc.params(item: T.type_parameter(:B)).returns(T.untyped) + ).returns(T::Array[[T.type_parameter(:A), T.type_parameter(:B)]]) + end + def zip_by(a, fa, b, fb); end + + class << self + sig do + params( + filename: ::String, + source: ::String, + generator: T.nilable(::Parlour::RbiGenerator) + ).returns(::Parlour::TypeParser) + end + def from_source(filename, source, generator: T.unsafe(nil)); end + + sig { params(str: ::String).returns(::Parlour::Types::Type) } + def parse_single_type(str); end + end +end + +class Parlour::TypeParser::IntermediateSig < ::T::Struct + prop :abstract, T::Boolean + prop :final, T::Boolean + prop :overridable, T::Boolean + prop :override, T::Boolean + prop :params, T.nilable(T::Array[::Parser::AST::Node]) + prop :return_type, T.nilable(::String) + prop :type_parameters, T.nilable(T::Array[::Symbol]) + + class << self + def inherited(s); end + end +end + +class Parlour::TypeParser::NodePath + sig { params(indices: T::Array[::Integer]).void } + def initialize(indices); end + + sig { params(index: ::Integer).returns(::Parlour::TypeParser::NodePath) } + def child(index); end + + sig { returns(T::Array[::Integer]) } + def indices; end + + sig { returns(::Parlour::TypeParser::NodePath) } + def parent; end + + sig { params(offset: ::Integer).returns(::Parlour::TypeParser::NodePath) } + def sibling(offset); end + + sig { params(start: ::Parser::AST::Node).returns(::Parser::AST::Node) } + def traverse(start); end +end + +class Parlour::TypedObject + abstract! + + sig { params(name: ::String).void } + def initialize(name); end + + sig { params(comment: T.any(::String, T::Array[::String])).void } + def add_comment(comment); end + + def add_comments(*args, &blk); end + + sig { returns(T::Array[::String]) } + def comments; end + + sig { returns(::String) } + def describe; end + + sig { params(tree: T.nilable(::Parlour::Debugging::Tree)).returns(::String) } + def describe_tree(tree: T.unsafe(nil)); end + + sig { returns(T.nilable(::Parlour::Plugin)) } + def generated_by; end + + def inspect(*args, &blk); end + + sig { returns(::String) } + def name; end + + def to_s(*args, &blk); end + + protected + + sig { abstract.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) } + def describe_attrs; end + + sig { params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) } + def generate_comments(indent_level, options); end +end + +module Parlour::Types; end + +class Parlour::Types::Array < ::Parlour::Types::SingleElementCollection + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def collection_name; end +end + +class Parlour::Types::Boolean < ::Parlour::Types::Type + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end +end + +class Parlour::Types::Class < ::Parlour::Types::Type + sig { params(type: T.any(::Parlour::Types::Type, ::String)).void } + def initialize(type); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(::Parlour::Types::Type) } + def type; end +end + +class Parlour::Types::Enumerable < ::Parlour::Types::SingleElementCollection + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def collection_name; end +end + +class Parlour::Types::Enumerator < ::Parlour::Types::SingleElementCollection + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def collection_name; end +end + +class Parlour::Types::Generic < ::Parlour::Types::Type + sig do + params( + type: T.any(::Parlour::Types::Type, ::String), + type_params: T::Array[T.any(::Parlour::Types::Type, ::String)] + ).void + end + def initialize(type, type_params); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(::Parlour::Types::Type) } + def type; end + + sig { returns(T::Array[::Parlour::Types::Type]) } + def type_params; end +end + +class Parlour::Types::Hash < ::Parlour::Types::Type + sig { params(key: T.any(::Parlour::Types::Type, ::String), value: T.any(::Parlour::Types::Type, ::String)).void } + def initialize(key, value); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(::Parlour::Types::Type) } + def key; end + + sig { returns(::Parlour::Types::Type) } + def value; end +end + +class Parlour::Types::Intersection < ::Parlour::Types::Type + sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void } + def initialize(types); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(T::Array[::Parlour::Types::Type]) } + def types; end +end + +class Parlour::Types::Nilable < ::Parlour::Types::Type + sig { params(type: T.any(::Parlour::Types::Type, ::String)).void } + def initialize(type); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(::Parlour::Types::Type) } + def type; end +end + +class Parlour::Types::Proc < ::Parlour::Types::Type + sig do + params( + parameters: T::Array[::Parlour::Types::Proc::Parameter], + return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)) + ).void + end + def initialize(parameters, return_type); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(T::Array[::Parlour::Types::Proc::Parameter]) } + def parameters; end + + sig { returns(T.nilable(::Parlour::Types::Type)) } + def return_type; end +end + +class Parlour::Types::Proc::Parameter + sig { params(name: ::String, type: T.any(::Parlour::Types::Type, ::String), default: T.nilable(::String)).void } + def initialize(name, type, default = T.unsafe(nil)); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { returns(T.nilable(::String)) } + def default; end + + sig { returns(::String) } + def name; end + + sig { returns(::Parlour::Types::Type) } + def type; end +end + +class Parlour::Types::Range < ::Parlour::Types::SingleElementCollection + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def collection_name; end +end + +class Parlour::Types::Raw < ::Parlour::Types::Type + sig { params(str: ::String).void } + def initialize(str); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(::String) } + def str; end +end + +class Parlour::Types::Record < ::Parlour::Types::Type + sig { params(keys_to_types: T::Hash[::Symbol, T.any(::Parlour::Types::Type, ::String)]).void } + def initialize(keys_to_types); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(T::Hash[::Symbol, ::Parlour::Types::Type]) } + def keys_to_types; end +end + +class Parlour::Types::Self < ::Parlour::Types::Type + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end +end + +class Parlour::Types::Set < ::Parlour::Types::SingleElementCollection + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def collection_name; end +end + +class Parlour::Types::SingleElementCollection < ::Parlour::Types::Type + abstract! + + sig { params(element: T.any(::Parlour::Types::Type, ::String)).void } + def initialize(element); end + + sig { abstract.returns(::String) } + def collection_name; end + + sig { override.returns(::String) } + def describe; end + + sig { returns(::Parlour::Types::Type) } + def element; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end +end + +class Parlour::Types::Tuple < ::Parlour::Types::Type + sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void } + def initialize(types); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(T::Array[::Parlour::Types::Type]) } + def types; end +end + +class Parlour::Types::Type + abstract! + + def initialize(*args, &blk); end + + sig { abstract.returns(::String) } + def describe; end + + sig { abstract.returns(::String) } + def generate_rbi; end + + sig { abstract.returns(::String) } + def generate_rbs; end + + def hash; end + + sig { params(type_like: T.any(::Parlour::Types::Type, ::String)).returns(::Parlour::Types::Type) } + def to_type(type_like); end + + class << self + sig { params(type_like: T.any(::Parlour::Types::Type, ::String)).returns(::Parlour::Types::Type) } + def to_type(type_like); end + end +end + +Parlour::Types::TypeLike = T.type_alias { T.any(::Parlour::Types::Type, ::String) } + +class Parlour::Types::Union < ::Parlour::Types::Type + sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void } + def initialize(types); end + + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end + + sig { returns(T::Array[::Parlour::Types::Type]) } + def types; end +end + +class Parlour::Types::Untyped < ::Parlour::Types::Type + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + sig { override.returns(::String) } + def describe; end + + sig { override.returns(::String) } + def generate_rbi; end + + sig { override.returns(::String) } + def generate_rbs; end +end + +Parlour::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi index a417982c4d..b5ef7f4ad2 100644 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi @@ -3931,7 +3931,7 @@ class Parlour::Conversion::Converter extend ::T::Private::Methods::SingletonMethodHooks end -module Parlour::Debugging::Tree +class Parlour::Debugging::Tree extend ::T::Sig extend ::T::Private::Methods::MethodHooks extend ::T::Private::Methods::SingletonMethodHooks @@ -3949,6 +3949,14 @@ class Parlour::Generator extend ::T::Private::Methods::SingletonMethodHooks end +module Parlour::Mixin::Searchable + extend ::T::Sig + extend ::T::Private::Abstract::Hooks + extend ::T::InterfaceWrapper::Helpers + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + class Parlour::Options extend ::T::Sig extend ::T::Private::Methods::MethodHooks From 2ca517c79a5323311e502668e3bca76d3adfbc12 Mon Sep 17 00:00:00 2001 From: Bo Anderson Date: Mon, 2 May 2022 20:59:43 +0100 Subject: [PATCH 6/7] dev-cmd/typecheck: add --all switch --- Library/Homebrew/dev-cmd/typecheck.rb | 7 ++++++- completions/bash/brew | 2 ++ completions/fish/brew.fish | 2 ++ completions/zsh/_brew | 2 ++ docs/Manpage.md | 2 ++ manpages/brew.1 | 6 +++++- 6 files changed, 19 insertions(+), 2 deletions(-) diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb index 7f1c41e541..961b10adfd 100644 --- a/Library/Homebrew/dev-cmd/typecheck.rb +++ b/Library/Homebrew/dev-cmd/typecheck.rb @@ -20,6 +20,9 @@ module Homebrew description: "Silence all non-critical errors." switch "--update", description: "Update RBI files." + switch "--all", + depends_on: "--update", + description: "Regenerate all RBI files rather than just updated gems." switch "--suggest-typed", depends_on: "--update", description: "Try upgrading `typed` sigils." @@ -52,9 +55,11 @@ module Homebrew "did_you_mean", # RBI file is already provided by Sorbet "webrobots", # RBI file is bugged ] + tapioca_args = ["--exclude", *excluded_gems] + tapioca_args << "--all" if args.all? ohai "Updating Tapioca RBI files..." - system "bundle", "exec", "tapioca", "gem", "--exclude", *excluded_gems + system "bundle", "exec", "tapioca", "gem", *tapioca_args system "bundle", "exec", "parlour" system "bundle", "exec", "srb", "rbi", "hidden-definitions" system "bundle", "exec", "srb", "rbi", "todo" diff --git a/completions/bash/brew b/completions/bash/brew index dcf076a250..fc313f57e4 100644 --- a/completions/bash/brew +++ b/completions/bash/brew @@ -1965,6 +1965,7 @@ _brew_tc() { case "${cur}" in -*) __brewcomp " + --all --debug --dir --fail-if-not-changed @@ -2033,6 +2034,7 @@ _brew_typecheck() { case "${cur}" in -*) __brewcomp " + --all --debug --dir --fail-if-not-changed diff --git a/completions/fish/brew.fish b/completions/fish/brew.fish index 4aa29c4e02..7e618a2bb3 100644 --- a/completions/fish/brew.fish +++ b/completions/fish/brew.fish @@ -1333,6 +1333,7 @@ __fish_brew_complete_arg 'tap-new' -a '(__fish_brew_suggest_taps_installed)' __fish_brew_complete_cmd 'tc' 'Check for typechecking errors using Sorbet' +__fish_brew_complete_arg 'tc' -l all -d 'Regenerate all RBI files rather than just updated gems' __fish_brew_complete_arg 'tc' -l debug -d 'Display any debugging information' __fish_brew_complete_arg 'tc' -l dir -d 'Typecheck all files in a specific directory' __fish_brew_complete_arg 'tc' -l fail-if-not-changed -d 'Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update' @@ -1374,6 +1375,7 @@ __fish_brew_complete_arg 'tests' -l verbose -d 'Make some output more verbose' __fish_brew_complete_cmd 'typecheck' 'Check for typechecking errors using Sorbet' +__fish_brew_complete_arg 'typecheck' -l all -d 'Regenerate all RBI files rather than just updated gems' __fish_brew_complete_arg 'typecheck' -l debug -d 'Display any debugging information' __fish_brew_complete_arg 'typecheck' -l dir -d 'Typecheck all files in a specific directory' __fish_brew_complete_arg 'typecheck' -l fail-if-not-changed -d 'Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update' diff --git a/completions/zsh/_brew b/completions/zsh/_brew index 6ef8bf878c..cb0c5c80ca 100644 --- a/completions/zsh/_brew +++ b/completions/zsh/_brew @@ -1631,6 +1631,7 @@ _brew_tap_new() { # brew tc _brew_tc() { _arguments \ + '--all[Regenerate all RBI files rather than just updated gems]' \ '--debug[Display any debugging information]' \ '(--file)--dir[Typecheck all files in a specific directory]' \ '--fail-if-not-changed[Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update]' \ @@ -1679,6 +1680,7 @@ _brew_tests() { # brew typecheck _brew_typecheck() { _arguments \ + '--all[Regenerate all RBI files rather than just updated gems]' \ '--debug[Display any debugging information]' \ '(--file)--dir[Typecheck all files in a specific directory]' \ '--fail-if-not-changed[Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update]' \ diff --git a/docs/Manpage.md b/docs/Manpage.md index fefb74d3c1..692ade7c6e 100644 --- a/docs/Manpage.md +++ b/docs/Manpage.md @@ -1478,6 +1478,8 @@ Check for typechecking errors using Sorbet. Silence all non-critical errors. * `--update`: Update RBI files. +* `--all`: + Regenerate all RBI files rather than just updated gems. * `--suggest-typed`: Try upgrading `typed` sigils. * `--fail-if-not-changed`: diff --git a/manpages/brew.1 b/manpages/brew.1 index daf8a98ff4..b3e2dda1d0 100644 --- a/manpages/brew.1 +++ b/manpages/brew.1 @@ -1,7 +1,7 @@ .\" generated with Ronn/v0.7.3 .\" http://github.com/rtomayko/ronn/tree/0.7.3 . -.TH "BREW" "1" "March 2022" "Homebrew" "brew" +.TH "BREW" "1" "May 2022" "Homebrew" "brew" . .SH "NAME" \fBbrew\fR \- The Missing Package Manager for macOS (or Linux) @@ -2106,6 +2106,10 @@ Silence all non\-critical errors\. Update RBI files\. . .TP +\fB\-\-all\fR +Regenerate all RBI files rather than just updated gems\. +. +.TP \fB\-\-suggest\-typed\fR Try upgrading \fBtyped\fR sigils\. . From bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf Mon Sep 17 00:00:00 2001 From: Bo Anderson Date: Mon, 2 May 2022 20:59:59 +0100 Subject: [PATCH 7/7] Renegerate all RBI files for new Sorbet --- .../sorbet/rbi/gems/addressable@2.8.0.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi | 4 +- .../sorbet/rbi/gems/bindata@2.4.10.rbi | 4 +- .../sorbet/rbi/gems/byebug@11.1.3.rbi | 4 +- .../sorbet/rbi/gems/coderay@1.1.3.rbi | 4 +- .../sorbet/rbi/gems/commander@4.6.0.rbi | 8 +- .../sorbet/rbi/gems/connection_pool@2.2.5.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi | 4 +- .../rbi/gems/domain_name@0.5.20190701.rbi | 4 +- .../sorbet/rbi/gems/elftools@1.1.3.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi | 4 +- .../sorbet/rbi/gems/highline@2.0.3.rbi | 8 +- .../sorbet/rbi/gems/hpricot@0.8.6.rbi | 8 +- .../sorbet/rbi/gems/http-cookie@1.0.4.rbi | 4 +- .../sorbet/rbi/gems/method_source@1.0.0.rbi | 4 +- .../sorbet/rbi/gems/mustache@1.1.1.rbi | 4 +- .../rbi/gems/net-http-digest_auth@1.4.1.rbi | 4 +- .../rbi/gems/net-http-persistent@4.0.1.rbi | 4 +- .../sorbet/rbi/gems/patchelf@1.3.0.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi | 8 +- .../Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi | 9 +- .../Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi | 8 +- .../Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi | 13 +- .../sorbet/rbi/gems/rdiscount@2.2.0.2.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi | 4 +- .../sorbet/rbi/gems/rspec-github@2.3.1.rbi | 6 +- .../sorbet/rbi/gems/rspec-its@1.3.0.rbi | 6 +- .../sorbet/rbi/gems/rspec-retry@0.6.2.rbi | 6 +- .../sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi | 2 + .../sorbet/rbi/gems/rspec-wait@0.0.9.rbi | 6 +- .../sorbet/rbi/gems/rubocop@1.27.0.rbi | 15 +-- .../rbi/gems/ruby-progressbar@1.11.0.rbi | 4 +- .../sorbet/rbi/gems/rubyntlm@0.6.3.rbi | 4 +- .../sorbet/rbi/gems/simplecov-html@0.12.3.rbi | 4 +- .../sorbet/rbi/gems/simplecov@0.21.2.rbi | 4 +- .../rbi/gems/sorbet-runtime-stub@0.2.0.rbi | 4 +- .../sorbet/rbi/gems/tapioca@0.7.2.rbi | 2 +- .../Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi | 4 +- .../Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi | 4 +- .../rbi/gems/unicode-display_width@2.1.0.rbi | 4 +- .../sorbet/rbi/gems/uri_template@0.7.0.rbi | 4 +- .../sorbet/rbi/gems/warning@1.2.1.rbi | 4 +- .../sorbet/rbi/gems/webrick@1.7.0.rbi | 4 +- .../sorbet/rbi/gems/yard-sorbet@0.6.1.rbi | 116 ++++++++++++------ .../Homebrew/sorbet/rbi/gems/yard@0.9.27.rbi | 73 ++++++++++- .../sorbet/rbi/hidden-definitions/hidden.rbi | 66 ---------- 48 files changed, 278 insertions(+), 206 deletions(-) diff --git a/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi b/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi index 6c11175ba0..6537967e4f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `addressable` gem. # Please instead update this file by running `bin/tapioca gem addressable`. -# typed: true - module Addressable; end module Addressable::IDNA diff --git a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi index 34597045d1..687dae5b0e 100644 --- a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `ast` gem. # Please instead update this file by running `bin/tapioca gem ast`. -# typed: true - module AST; end class AST::Node diff --git a/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi b/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi index 9ac17de4fd..2bf86efb7f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `bindata` gem. # Please instead update this file by running `bin/tapioca gem bindata`. -# typed: true - module BinData extend ::BinData::BitFieldFactory extend ::BinData::IntFactory diff --git a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi index bb71fb89c5..da405adea8 100644 --- a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `byebug` gem. # Please instead update this file by running `bin/tapioca gem byebug`. -# typed: true - module Byebug class << self def attach; end diff --git a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi index d236e88b93..1cf355998a 100644 --- a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `coderay` gem. # Please instead update this file by running `bin/tapioca gem coderay`. -# typed: true - module CodeRay class << self def coderay_path(*path); end diff --git a/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi index a6d3fa183b..a0da6d393c 100644 --- a/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi @@ -1,8 +1,10 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `commander` gem. # Please instead update this file by running `bin/tapioca gem commander`. -# typed: true +::RUBY19 = T.let(T.unsafe(nil), TrueClass) module Blank class << self @@ -253,14 +255,14 @@ end Commander::VERSION = T.let(T.unsafe(nil), String) class Object < ::BasicObject + include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::ActiveSupport::ForkTracker::CoreExt include ::ActiveSupport::ForkTracker::CoreExtPrivate - include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::Kernel include ::JSON::Ext::Generator::GeneratorMethods::Object include ::PP::ObjectMixin - include ::ActiveSupport::Tryable include ::ActiveSupport::Dependencies::Loadable + include ::ActiveSupport::Tryable def get_binding; end end diff --git a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi index e1b01ef4aa..05e842256d 100644 --- a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `connection_pool` gem. # Please instead update this file by running `bin/tapioca gem connection_pool`. -# typed: true - class ConnectionPool def initialize(options = T.unsafe(nil), &block); end diff --git a/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi index 35ad3bc787..d8a14c5721 100644 --- a/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `docile` gem. # Please instead update this file by running `bin/tapioca gem docile`. -# typed: true - module Docile extend ::Docile::Execution diff --git a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi index b3461eb925..7e96cdabf2 100644 --- a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `domain_name` gem. # Please instead update this file by running `bin/tapioca gem domain_name`. -# typed: true - class DomainName def initialize(hostname); end diff --git a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi index 9c0a70784c..18eca679b8 100644 --- a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `elftools` gem. # Please instead update this file by running `bin/tapioca gem elftools`. -# typed: true - module ELFTools; end module ELFTools::Constants diff --git a/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi b/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi index cb12a5e7c2..042aa1baf1 100644 --- a/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `hana` gem. # Please instead update this file by running `bin/tapioca gem hana`. -# typed: true - module Hana; end class Hana::Patch diff --git a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi index 6d7dac4e8b..87172a89cc 100644 --- a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi @@ -1,8 +1,10 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `highline` gem. # Please instead update this file by running `bin/tapioca gem highline`. -# typed: true +::RUBY19 = T.let(T.unsafe(nil), TrueClass) class HighLine include ::HighLine::BuiltinStyles @@ -838,14 +840,14 @@ module HighLine::Wrapper end class Object < ::BasicObject + include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::ActiveSupport::ForkTracker::CoreExt include ::ActiveSupport::ForkTracker::CoreExtPrivate - include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::Kernel include ::JSON::Ext::Generator::GeneratorMethods::Object include ::PP::ObjectMixin - include ::ActiveSupport::Tryable include ::ActiveSupport::Dependencies::Loadable + include ::ActiveSupport::Tryable def or_ask(*args, &details); end end diff --git a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi index 5c89f93acd..c07ed11de1 100644 --- a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi @@ -1,8 +1,10 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `hpricot` gem. # Please instead update this file by running `bin/tapioca gem hpricot`. -# typed: true +::RUBY19 = T.let(T.unsafe(nil), TrueClass) module Hpricot class << self @@ -628,14 +630,14 @@ module Hpricot::XMLDecl::Trav end class Object < ::BasicObject + include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::ActiveSupport::ForkTracker::CoreExt include ::ActiveSupport::ForkTracker::CoreExtPrivate - include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::Kernel include ::JSON::Ext::Generator::GeneratorMethods::Object include ::PP::ObjectMixin - include ::ActiveSupport::Tryable include ::ActiveSupport::Dependencies::Loadable + include ::ActiveSupport::Tryable private diff --git a/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.4.rbi b/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.4.rbi index dde9817788..e55f34138a 100644 --- a/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.4.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.4.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `http-cookie` gem. # Please instead update this file by running `bin/tapioca gem http-cookie`. -# typed: true - module HTTP; end class HTTP::Cookie diff --git a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi index 5807b25186..b7ecbb6947 100644 --- a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `method_source` gem. # Please instead update this file by running `bin/tapioca gem method_source`. -# typed: true - module MethodSource extend ::MethodSource::CodeHelpers diff --git a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi index 64b086d8a6..175edbe2b8 100644 --- a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `mustache` gem. # Please instead update this file by running `bin/tapioca gem mustache`. -# typed: true - class Mustache def initialize(options = T.unsafe(nil)); end diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi index 8330013aee..8b0051b417 100644 --- a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi @@ -1,8 +1,8 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `net-http-digest_auth` gem. # Please instead update this file by running `bin/tapioca gem net-http-digest_auth`. -# typed: true - # THIS IS AN EMPTY RBI FILE. # see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi index 9f18e0a12b..81e139b7e6 100644 --- a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `net-http-persistent` gem. # Please instead update this file by running `bin/tapioca gem net-http-persistent`. -# typed: true - class Net::HTTP::Persistent def initialize(name: T.unsafe(nil), proxy: T.unsafe(nil), pool_size: T.unsafe(nil)); end diff --git a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi index 37ef247658..be5c04a6ec 100644 --- a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `patchelf` gem. # Please instead update this file by running `bin/tapioca gem patchelf`. -# typed: true - module PatchELF; end module PatchELF::Helper diff --git a/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi index d269bf8c54..4e521bb855 100644 --- a/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `plist` gem. # Please instead update this file by running `bin/tapioca gem plist`. -# typed: true - module Plist class << self def parse_xml(filename_or_xml); end diff --git a/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi b/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi index 635514f42f..8f04fe9c6f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi @@ -1,22 +1,24 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `pry` gem. # Please instead update this file by running `bin/tapioca gem pry`. -# typed: true +::RUBY19 = T.let(T.unsafe(nil), TrueClass) class BasicObject def __binding__; end end class Object < ::BasicObject + include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::ActiveSupport::ForkTracker::CoreExt include ::ActiveSupport::ForkTracker::CoreExtPrivate - include ::ActiveSupport::ToJsonWithActiveSupportEncoder include ::Kernel include ::JSON::Ext::Generator::GeneratorMethods::Object include ::PP::ObjectMixin - include ::ActiveSupport::Tryable include ::ActiveSupport::Dependencies::Loadable + include ::ActiveSupport::Tryable def __binding__; end def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end diff --git a/Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi index f0f050c7d4..93e67bf5e0 100644 --- a/Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi @@ -1,13 +1,20 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `racc` gem. # Please instead update this file by running `bin/tapioca gem racc`. -# typed: true +::RUBY19 = T.let(T.unsafe(nil), TrueClass) class Object < ::BasicObject + include ::ActiveSupport::ToJsonWithActiveSupportEncoder + include ::ActiveSupport::ForkTracker::CoreExt + include ::ActiveSupport::ForkTracker::CoreExtPrivate include ::Kernel include ::JSON::Ext::Generator::GeneratorMethods::Object include ::PP::ObjectMixin + include ::ActiveSupport::Dependencies::Loadable + include ::ActiveSupport::Tryable end ParseError = Racc::ParseError diff --git a/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi index 836e5ae627..8b8f9b3a11 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rack` gem. # Please instead update this file by running `bin/tapioca gem rack`. -# typed: true - module Rack class << self def release; end @@ -934,7 +934,11 @@ class Rack::Request def delete_param(k); end def params; end + def query; end def update_param(k, v); end + def version_supplied; end + def version_supplied=(_arg0); end + def xhr?; end class << self def ip_filter; end diff --git a/Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi b/Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi index ba6f3b6568..c11faca967 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi @@ -1842,8 +1842,17 @@ class RBI::Tree < ::RBI::NodeWithComments sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).void } def create_path(constant, &block); end - sig { params(name: ::String, value: ::String).void } - def create_type_member(name, value: T.unsafe(nil)); end + sig do + params( + name: ::String, + type: ::String, + variance: ::Symbol, + fixed: T.nilable(::String), + upper: T.nilable(::String), + lower: T.nilable(::String) + ).void + end + def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end sig { params(annotation: ::String).void } def deannotate!(annotation); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi index 44d3d0fa21..25b5f7e36c 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rdiscount` gem. # Please instead update this file by running `bin/tapioca gem rdiscount`. -# typed: true - Markdown = RDiscount class RDiscount diff --git a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi index 5b06afcfe1..493c0fc36f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rexml` gem. # Please instead update this file by running `bin/tapioca gem rexml`. -# typed: true - class REXML::AttlistDecl < ::REXML::Child include ::Enumerable diff --git a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi index e13cdde092..0db9fe7be6 100644 --- a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `ronn` gem. # Please instead update this file by running `bin/tapioca gem ronn`. -# typed: true - module Ronn class << self def new(filename, attributes = T.unsafe(nil), &block); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi index 8d70105b42..b914a4df24 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rspec-github` gem. # Please instead update this file by running `bin/tapioca gem rspec-github`. -# typed: true - module RSpec extend ::RSpec::Support::Warnings extend ::RSpec::Core::Warnings @@ -17,6 +17,8 @@ module RSpec def context(*args, &example_group_block); end def current_example; end def current_example=(example); end + def current_scope; end + def current_scope=(scope); end def describe(*args, &example_group_block); end def example_group(*args, &example_group_block); end def fcontext(*args, &example_group_block); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi index 143d730d52..a7d7d2ab22 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rspec-its` gem. # Please instead update this file by running `bin/tapioca gem rspec-its`. -# typed: true - module RSpec extend ::RSpec::Support::Warnings extend ::RSpec::Core::Warnings @@ -17,6 +17,8 @@ module RSpec def context(*args, &example_group_block); end def current_example; end def current_example=(example); end + def current_scope; end + def current_scope=(scope); end def describe(*args, &example_group_block); end def example_group(*args, &example_group_block); end def fcontext(*args, &example_group_block); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi index f610b1f12d..cfd169a1b8 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rspec-retry` gem. # Please instead update this file by running `bin/tapioca gem rspec-retry`. -# typed: true - module RSpec extend ::RSpec::Support::Warnings extend ::RSpec::Core::Warnings @@ -17,6 +17,8 @@ module RSpec def context(*args, &example_group_block); end def current_example; end def current_example=(example); end + def current_scope; end + def current_scope=(scope); end def describe(*args, &example_group_block); end def example_group(*args, &example_group_block); end def fcontext(*args, &example_group_block); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi index 390ce8f60c..e0a60bf71f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi @@ -17,6 +17,8 @@ module RSpec def context(*args, &example_group_block); end def current_example; end def current_example=(example); end + def current_scope; end + def current_scope=(scope); end def describe(*args, &example_group_block); end def example_group(*args, &example_group_block); end def fcontext(*args, &example_group_block); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi index 85dc176db2..e91ffd7b18 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rspec-wait` gem. # Please instead update this file by running `bin/tapioca gem rspec-wait`. -# typed: true - module RSpec extend ::RSpec::Support::Warnings extend ::RSpec::Core::Warnings @@ -17,6 +17,8 @@ module RSpec def context(*args, &example_group_block); end def current_example; end def current_example=(example); end + def current_scope; end + def current_scope=(scope); end def describe(*args, &example_group_block); end def example_group(*args, &example_group_block); end def fcontext(*args, &example_group_block); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.27.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.27.0.rbi index 454826ffb4..6f6494eb17 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.27.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.27.0.rbi @@ -2693,10 +2693,6 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base def force_equal_sign_alignment?; end def ignored_range?(ast, start_pos); end def ignored_ranges(ast); end - - class << self - def autocorrect_incompatible_with; end - end end RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String) @@ -9706,6 +9702,7 @@ end RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue include ::RuboCop::Cop::FrozenStringLiteral include ::RuboCop::Cop::ConfigurableEnforcedStyle @@ -9715,6 +9712,7 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end def splat_value(param0 = T.unsafe(nil)); end + def t_let(param0 = T.unsafe(nil)); end private @@ -9724,7 +9722,6 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base def frozen_regexp_or_range_literals?(node); end def immutable_literal?(node); end def mutable_literal?(value); end - def on_assignment(value); end def requires_parentheses?(node); end def shareable_constant_value?(node); end def strict_check(value); end @@ -11703,10 +11700,6 @@ class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base def on_csend(node); end def on_send(node); end - - class << self - def autocorrect_incompatible_with; end - end end class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Base @@ -12991,8 +12984,8 @@ end RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String) -RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter) -RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter) +RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter) +RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter) class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter include ::RuboCop::Formatter::TextUtil diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi index 1426cc6630..5d5a84fe10 100644 --- a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `ruby-progressbar` gem. # Please instead update this file by running `bin/tapioca gem ruby-progressbar`. -# typed: true - class ProgressBar class << self def create(*args); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi index 4d39600529..3d559d3c3f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rubyntlm` gem. # Please instead update this file by running `bin/tapioca gem rubyntlm`. -# typed: true - module Net::NTLM class << self def apply_des(plain, keys); end diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi index 3b680d3292..4053d47423 100644 --- a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `simplecov-html` gem. # Please instead update this file by running `bin/tapioca gem simplecov-html`. -# typed: true - module SimpleCov extend ::SimpleCov::Configuration diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi index 4d6e94d11a..0e594824e2 100644 --- a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `simplecov` gem. # Please instead update this file by running `bin/tapioca gem simplecov`. -# typed: true - module SimpleCov extend ::SimpleCov::Configuration diff --git a/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi index 36d74d4291..6f0613cfb3 100644 --- a/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi @@ -1,8 +1,8 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `sorbet-runtime-stub` gem. # Please instead update this file by running `bin/tapioca gem sorbet-runtime-stub`. -# typed: true - # THIS IS AN EMPTY RBI FILE. # see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi index 565caf95d2..5ac4bf25cd 100644 --- a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi @@ -592,7 +592,7 @@ class Tapioca::Dsl::Compiler abstract! - ConstantType = type_member(upper: Module) + ConstantType = type_member { { upper: Module } } sig { params(pipeline: ::Tapioca::Dsl::Pipeline, root: ::RBI::Tree, constant: ConstantType).void } def initialize(pipeline, root, constant); end diff --git a/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi b/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi index 9a0d2be2c8..4928930bce 100644 --- a/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `tzinfo` gem. # Please instead update this file by running `bin/tapioca gem tzinfo`. -# typed: true - module TZInfo; end class TZInfo::AbsoluteDayOfYearTransitionRule < ::TZInfo::DayOfYearTransitionRule diff --git a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi index 6872ff0d85..4ae42ce42e 100644 --- a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `unf` gem. # Please instead update this file by running `bin/tapioca gem unf`. -# typed: true - module UNF; end class UNF::Normalizer diff --git a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi index 5dd4597031..1974cb0f8c 100644 --- a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `unicode-display_width` gem. # Please instead update this file by running `bin/tapioca gem unicode-display_width`. -# typed: true - module Unicode; end class Unicode::DisplayWidth diff --git a/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi index 1afa6741ac..527645fd84 100644 --- a/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `uri_template` gem. # Please instead update this file by running `bin/tapioca gem uri_template`. -# typed: true - module URITemplate extend ::URITemplate::ClassMethods diff --git a/Library/Homebrew/sorbet/rbi/gems/warning@1.2.1.rbi b/Library/Homebrew/sorbet/rbi/gems/warning@1.2.1.rbi index dc4b3ee07c..d27162412d 100644 --- a/Library/Homebrew/sorbet/rbi/gems/warning@1.2.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/warning@1.2.1.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `warning` gem. # Please instead update this file by running `bin/tapioca gem warning`. -# typed: true - module Warning extend ::Warning extend ::Warning::Processor diff --git a/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi index 5c34dadabd..63755aa3aa 100644 --- a/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi @@ -1,9 +1,9 @@ +# typed: true + # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `webrick` gem. # Please instead update this file by running `bin/tapioca gem webrick`. -# typed: true - module WEBrick::AccessLog private diff --git a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi b/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi index 21e2d580ac..ca4ab82082 100644 --- a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi @@ -8,10 +8,10 @@ module YARDSorbet; end module YARDSorbet::Directives class << self - sig { params(docstring: String, directives: T::Array[String]).void } + sig { params(docstring: ::String, directives: T::Array[::String]).void } def add_directives(docstring, directives); end - sig { params(docstring: T.nilable(String)).returns([YARD::Docstring, T::Array[String]]) } + sig { params(docstring: T.nilable(::String)).returns([::YARD::Docstring, T::Array[::String]]) } def extract_directives(docstring); end end end @@ -32,7 +32,7 @@ class YARDSorbet::Handlers::EnumsHandler < ::YARD::Handlers::Ruby::Base private - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Boolean) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Boolean) } def const_assign_node?(node); end end @@ -42,7 +42,7 @@ class YARDSorbet::Handlers::IncludeHandler < ::YARD::Handlers::Ruby::Base private - sig { returns(YARD::CodeObjects::NamespaceObject) } + sig { returns(::YARD::CodeObjects::NamespaceObject) } def included_in; end end @@ -51,7 +51,7 @@ class YARDSorbet::Handlers::MixesInClassMethodsHandler < ::YARD::Handlers::Ruby: def process; end class << self - sig { params(code_obj: String).returns(T.nilable(String)) } + sig { params(code_obj: ::String).returns(T.nilable(::String)) } def mixed_in_class_methods(code_obj); end end end @@ -62,13 +62,19 @@ class YARDSorbet::Handlers::SigHandler < ::YARD::Handlers::Ruby::Base private - sig { params(method_node: YARD::Parser::Ruby::AstNode, node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void } + sig do + params( + method_node: ::YARD::Parser::Ruby::AstNode, + node: ::YARD::Parser::Ruby::AstNode, + docstring: ::YARD::Docstring + ).void + end def parse_params(method_node, node, docstring); end - sig { params(node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void } + sig { params(node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void } def parse_return(node, docstring); end - sig { params(method_node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void } + sig { params(method_node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void } def parse_sig(method_node, docstring); end end @@ -80,13 +86,20 @@ module YARDSorbet::Handlers::StructClassHandler private - sig { params(object: YARD::CodeObjects::MethodObject, props: T::Array[YARDSorbet::TStructProp], docstring: YARD::Docstring, directives: T::Array[String]).void } + sig do + params( + object: ::YARD::CodeObjects::MethodObject, + props: T::Array[::YARDSorbet::TStructProp], + docstring: ::YARD::Docstring, + directives: T::Array[::String] + ).void + end def decorate_t_struct_init(object, props, docstring, directives); end - sig { params(props: T::Array[YARDSorbet::TStructProp], class_ns: YARD::CodeObjects::ClassObject).void } + sig { params(props: T::Array[::YARDSorbet::TStructProp], class_ns: ::YARD::CodeObjects::ClassObject).void } def process_t_struct_props(props, class_ns); end - sig { params(props: T::Array[YARDSorbet::TStructProp]).returns(T::Array[[String, T.nilable(String)]]) } + sig { params(props: T::Array[::YARDSorbet::TStructProp]).returns(T::Array[[::String, T.nilable(::String)]]) } def to_object_parameters(props); end end @@ -96,90 +109,99 @@ class YARDSorbet::Handlers::StructPropHandler < ::YARD::Handlers::Ruby::Base private - sig { params(object: YARD::CodeObjects::MethodObject, prop: YARDSorbet::TStructProp).void } + sig { params(object: ::YARD::CodeObjects::MethodObject, prop: ::YARDSorbet::TStructProp).void } def decorate_object(object, prop); end - sig { returns(T.nilable(String)) } + sig { returns(T.nilable(::String)) } def default_value; end - sig { params(name: String).returns(YARDSorbet::TStructProp) } + sig { params(name: ::String).returns(::YARDSorbet::TStructProp) } def make_prop(name); end - sig { params(object: YARD::CodeObjects::MethodObject, name: String).void } + sig { params(object: ::YARD::CodeObjects::MethodObject, name: ::String).void } def register_attrs(object, name); end - sig { params(prop: YARDSorbet::TStructProp).void } + sig { params(prop: ::YARDSorbet::TStructProp).void } def update_state(prop); end end module YARDSorbet::NodeUtils class << self - sig { params(node: YARD::Parser::Ruby::AstNode, _blk: T.proc.params(n: YARD::Parser::Ruby::AstNode).void).void } + sig do + params( + node: ::YARD::Parser::Ruby::AstNode, + _blk: T.proc.params(n: ::YARD::Parser::Ruby::AstNode).void + ).void + end def bfs_traverse(node, &_blk); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode)) } + sig do + params( + node: ::YARD::Parser::Ruby::AstNode + ).returns(T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode)) + end def get_method_node(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(YARD::Parser::Ruby::AstNode) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::YARD::Parser::Ruby::AstNode) } def sibling_node(node); end end end YARDSorbet::NodeUtils::ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Array) -YARDSorbet::NodeUtils::SIGABLE_NODE = T.type_alias { T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode) } +YARDSorbet::NodeUtils::SIGABLE_NODE = T.type_alias { T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode) } YARDSorbet::NodeUtils::SKIP_METHOD_CONTENTS = T.let(T.unsafe(nil), Array) module YARDSorbet::SigToYARD class << self - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert(node); end private - sig { params(node: YARD::Parser::Ruby::AstNode).returns(String) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::String) } def build_generic_type(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_aref(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_array(node); end - sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) } def convert_call(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_collection(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_hash(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_list(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_node(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_node_type(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_ref(node); end - sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) } def convert_t_method(node); end - sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) } + sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_unknown(node); end end end class YARDSorbet::TStructProp < ::T::Struct - const :default, T.nilable(String) - const :doc, String - const :prop_name, String - const :source, String - const :types, T::Array[String] + const :default, T.nilable(::String) + const :doc, ::String + const :prop_name, ::String + const :source, ::String + const :types, T::Array[::String] class << self def inherited(s); end @@ -188,10 +210,24 @@ end module YARDSorbet::TagUtils class << self - sig { params(docstring: YARD::Docstring, tag_name: String, name: T.nilable(String)).returns(T.nilable(YARD::Tags::Tag)) } + sig do + params( + docstring: ::YARD::Docstring, + tag_name: ::String, + name: T.nilable(::String) + ).returns(T.nilable(::YARD::Tags::Tag)) + end def find_tag(docstring, tag_name, name); end - sig { params(docstring: YARD::Docstring, tag_name: String, types: T.nilable(T::Array[String]), name: T.nilable(String), text: String).void } + sig do + params( + docstring: ::YARD::Docstring, + tag_name: ::String, + types: T.nilable(T::Array[::String]), + name: T.nilable(::String), + text: ::String + ).void + end def upsert_tag(docstring, tag_name, types = T.unsafe(nil), name = T.unsafe(nil), text = T.unsafe(nil)); end end end diff --git a/Library/Homebrew/sorbet/rbi/gems/yard@0.9.27.rbi b/Library/Homebrew/sorbet/rbi/gems/yard@0.9.27.rbi index 1bd8ec580a..41901c1154 100644 --- a/Library/Homebrew/sorbet/rbi/gems/yard@0.9.27.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/yard@0.9.27.rbi @@ -79,6 +79,37 @@ end Gem::USE_BUNDLER_FOR_GEMDEPS = T.let(T.unsafe(nil), TrueClass) Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError +class IRB::SLex + def initialize; end + + def create(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end + def def_rule(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil), &block); end + def def_rules(*tokens, &block); end + def inspect; end + def match(token); end + def postproc(token); end + def preproc(token, proc); end + def search(token); end +end + +IRB::SLex::DOUT = T.let(T.unsafe(nil), IRB::Notifier::CompositeNotifier) +IRB::SLex::D_DEBUG = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier) +IRB::SLex::D_DETAIL = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier) +IRB::SLex::D_WARN = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier) + +class IRB::SLex::Node + def initialize(preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end + + def create_subnode(chrs, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end + def match(chrs, op = T.unsafe(nil)); end + def match_io(io, op = T.unsafe(nil)); end + def postproc; end + def postproc=(_arg0); end + def preproc; end + def preproc=(_arg0); end + def search(chrs, opt = T.unsafe(nil)); end +end + class Insertion def initialize(list, value); end @@ -93,11 +124,39 @@ class Insertion end class Module + include ::ActiveSupport::Dependencies::ModuleConstMissing + def class_name; end end +Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array) +Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set) +Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array) RUBY19 = T.let(T.unsafe(nil), TrueClass) +class Rack::Request + include ::Rack::Request::Env + include ::Rack::Request::Helpers + + def initialize(env); end + + def delete_param(k); end + def params; end + def query; end + def update_param(k, v); end + def version_supplied; end + def version_supplied=(_arg0); end + def xhr?; end + + class << self + def ip_filter; end + def ip_filter=(_arg0); end + end +end + +Rack::Request::ALLOWED_SCHEMES = T.let(T.unsafe(nil), Array) +Rack::Request::SCHEME_WHITELIST = T.let(T.unsafe(nil), Array) + class String include ::Comparable include ::JSON::Ext::Generator::GeneratorMethods::String @@ -127,6 +186,14 @@ class SymbolHash < ::Hash end end +class WEBrick::HTTPRequest + def version_supplied; end + def version_supplied=(_arg0); end + def xhr?; end +end + +WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer) + module YARD class << self def load_plugins; end @@ -504,7 +571,11 @@ end YARD::CLI::YardoptsCommand::DEFAULT_YARDOPTS_FILE = T.let(T.unsafe(nil), String) YARD::CONFIG_DIR = T.let(T.unsafe(nil), String) -module YARD::CodeObjects; end + +module YARD::CodeObjects + extend ::YARD::CodeObjects::NamespaceMapper +end + YARD::CodeObjects::BUILTIN_ALL = T.let(T.unsafe(nil), Array) YARD::CodeObjects::BUILTIN_CLASSES = T.let(T.unsafe(nil), Array) YARD::CodeObjects::BUILTIN_EXCEPTIONS = T.let(T.unsafe(nil), Array) diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi index b5ef7f4ad2..b3ef715704 100644 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi @@ -2938,24 +2938,6 @@ class IRB::SLex def Fail(err=T.unsafe(nil), *rest); end def Raise(err=T.unsafe(nil), *rest); end - - def create(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end - - def def_rule(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil), &block); end - - def def_rules(*tokens, &block); end - - def match(token); end - - def postproc(token); end - - def preproc(token, proc); end - - def search(token); end - DOUT = ::T.let(nil, ::T.untyped) - D_DEBUG = ::T.let(nil, ::T.untyped) - D_DETAIL = ::T.let(nil, ::T.untyped) - D_WARN = ::T.let(nil, ::T.untyped) end class IRB::SLex::ErrNodeAlreadyExists @@ -2970,29 +2952,6 @@ end class IRB::SLex::ErrNodeNothing end -class IRB::SLex::Node - def create_subnode(chrs, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end - - def initialize(preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end - - def match(chrs, op=T.unsafe(nil)); end - - def match_io(io, op=T.unsafe(nil)); end - - def postproc(); end - - def postproc=(postproc); end - - def preproc(); end - - def preproc=(preproc); end - - def search(chrs, opt=T.unsafe(nil)); end -end - -class IRB::SLex::Node -end - class IRB::SLex extend ::Exception2MessageMapper def self.included(mod); end @@ -4338,14 +4297,6 @@ end class Racc::CparseParams end -class Rack::Request - def query(); end - - def version_supplied(); end - - def version_supplied=(version_supplied); end -end - class Random def self.bytes(arg); end end @@ -5247,11 +5198,6 @@ class RuboCop::Cop::FormulaCop def required_dependency_name?(param0, param1); end end -class RuboCop::Cop::Style::MutableConstant - include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour - def t_let(param0=T.unsafe(nil)); end -end - module RuboCop::RSpec::ExpectOffense def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end @@ -7212,14 +7158,6 @@ class Version extend ::T::Private::Methods::SingletonMethodHooks end -class WEBrick::HTTPRequest - def version_supplied(); end - - def version_supplied=(version_supplied); end - - def xhr?(); end -end - class WeakRef def initialize(orig); end end @@ -7431,10 +7369,6 @@ end module Webrobots end -module YARD::CodeObjects - extend ::YARD::CodeObjects::NamespaceMapper -end - module YARDSorbet::Directives extend ::T::Sig extend ::T::Private::Methods::MethodHooks