Merge pull request #15536 from Homebrew/dependabot/bundler/Library/Homebrew/parser-3.2.2.3

build(deps): bump parser from 3.2.2.1 to 3.2.2.3 in /Library/Homebrew

Library/Homebrew/Gemfile.lock

@@ -49,8 +49,9 @@ GEM
       parser
       rainbow (~> 3.0)
       sorbet-runtime (>= 0.5)
-    parser (3.2.2.1)
+    parser (3.2.2.3)
       ast (~> 2.4.1)
+      racc
     patchelf (1.4.0)
       elftools (>= 1.2)
     plist (3.7.0)
@@ -58,6 +59,7 @@ GEM
       coderay (~> 1.1)
       method_source (~> 1.0)
     public_suffix (5.0.1)
+    racc (1.7.1)
     rack (3.0.8)
     rainbow (3.1.1)
     rbi (0.0.14)

Library/Homebrew/sorbet/rbi/gems/racc@1.7.1.rbi

@@ -0,0 +1,644 @@
+# 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`.
+
+::APPLE_GEM_HOME = T.let(T.unsafe(nil), String)
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
+::RUBY_FRAMEWORK = T.let(T.unsafe(nil), TrueClass)
+::RUBY_FRAMEWORK_VERSION = T.let(T.unsafe(nil), String)
+
+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
+
+class Racc::Accept
+  def inspect; end
+end
+
+class Racc::ActionTable
+  def initialize(rt, st); end
+
+  def accept; end
+  def each_reduce(&block); end
+  def each_shift(&block); end
+  def error; end
+  def init; end
+  def reduce(i); end
+  def reduce_n; end
+  def shift(i); end
+  def shift_n; end
+end
+
+class Racc::CompileError < ::Racc::Error; end
+Racc::Copyright = T.let(T.unsafe(nil), String)
+
+class Racc::DebugFlags
+  def initialize(parse = T.unsafe(nil), rule = T.unsafe(nil), token = T.unsafe(nil), state = T.unsafe(nil), la = T.unsafe(nil), prec = T.unsafe(nil), conf = T.unsafe(nil)); end
+
+  def any?; end
+  def la; end
+  def parse; end
+  def prec; end
+  def rule; end
+  def state; end
+  def status_logging; end
+  def token; end
+
+  class << self
+    def parse_option_string(s); end
+  end
+end
+
+class Racc::Error < ::StandardError
+  def inspect; end
+end
+
+class Racc::Goto
+  def initialize(ident, sym, from, to); end
+
+  def from_state; end
+  def ident; end
+  def inspect; end
+  def symbol; end
+  def to_state; end
+end
+
+class Racc::Grammar
+  extend ::Forwardable
+
+  def initialize(debug_flags = T.unsafe(nil)); end
+
+  def [](x); end
+  def add(rule); end
+  def added?(sym); end
+  def declare_precedence(assoc, syms); end
+  def dfa; end
+  def each(&block); end
+  def each_index(&block); end
+  def each_nonterminal(*args, &block); end
+  def each_rule(&block); end
+  def each_symbol(*args, &block); end
+  def each_terminal(*args, &block); end
+  def each_useless_nonterminal; end
+  def each_useless_rule; end
+  def each_with_index(&block); end
+  def end_precedence_declaration(reverse); end
+  def init; end
+  def intern(value, dummy = T.unsafe(nil)); end
+  def n_expected_srconflicts; end
+  def n_expected_srconflicts=(_arg0); end
+  def n_useless_nonterminals; end
+  def n_useless_rules; end
+  def nfa; end
+  def nonterminal_base; end
+  def parser_class; end
+  def size; end
+  def start; end
+  def start_symbol=(s); end
+  def state_transition_table; end
+  def states; end
+  def symbols; end
+  def symboltable; end
+  def to_s; end
+  def useless_nonterminal_exist?; end
+  def useless_rule_exist?; end
+  def write_log(path); end
+
+  private
+
+  def _compute_expand(t, set, lock); end
+  def add_start_rule; end
+  def check_rules_nullable(rules); end
+  def check_rules_useless(rules); end
+  def check_symbols_nullable(symbols); end
+  def check_symbols_useless(s); end
+  def compute_expand(t); end
+  def compute_hash; end
+  def compute_heads; end
+  def compute_locate; end
+  def compute_nullable; end
+  def compute_nullable_0; end
+  def compute_useless; end
+  def determine_terminals; end
+  def fix_ident; end
+
+  class << self
+    def define(&block); end
+  end
+end
+
+class Racc::Grammar::DefinitionEnv
+  def initialize; end
+
+  def _(&block); end
+  def _add(target, x); end
+  def _added?(sym); end
+  def _delayed_add(rule); end
+  def _intern(x); end
+  def action(&block); end
+  def flush_delayed; end
+  def grammar; end
+  def many(sym, &block); end
+  def many1(sym, &block); end
+  def method_missing(mid, *args, &block); end
+  def null(&block); end
+  def option(sym, default = T.unsafe(nil), &block); end
+  def precedence_table(&block); end
+  def separated_by(sep, sym, &block); end
+  def separated_by1(sep, sym, &block); end
+  def seq(*list, &block); end
+
+  private
+
+  def _defmetasyntax(type, id, action, &block); end
+  def _register(target_name); end
+  def _wrap(target_name, sym, block); end
+end
+
+class Racc::Grammar::PrecedenceDefinitionEnv
+  def initialize(g); end
+
+  def higher; end
+  def left(*syms); end
+  def lower; end
+  def nonassoc(*syms); end
+  def reverse; end
+  def right(*syms); end
+end
+
+class Racc::ISet
+  def initialize(a = T.unsafe(nil)); end
+
+  def [](key); end
+  def []=(key, val); end
+  def add(i); end
+  def clear; end
+  def delete(key); end
+  def dup; end
+  def each(&block); end
+  def empty?; end
+  def include?(key); end
+  def inspect; end
+  def key?(key); end
+  def set; end
+  def size; end
+  def to_a; end
+  def to_s; end
+  def update(other); end
+  def update_a(a); end
+end
+
+class Racc::Item
+  def initialize(rule, la); end
+
+  def each_la(tbl); end
+  def la; end
+  def rule; end
+end
+
+class Racc::LocationPointer
+  def initialize(rule, i, sym); end
+
+  def ==(ot); end
+  def before(len); end
+  def dereference; end
+  def eql?(ot); end
+  def hash; end
+  def head?; end
+  def ident; end
+  def increment; end
+  def index; end
+  def inspect; end
+  def next; end
+  def reduce; end
+  def reduce?; end
+  def rule; end
+  def symbol; end
+  def to_s; end
+
+  private
+
+  def ptr_bug!; end
+end
+
+class Racc::LogFileGenerator
+  def initialize(states, debug_flags = T.unsafe(nil)); end
+
+  def action_out(f, state); end
+  def outact(f, t, act); end
+  def output(out); end
+  def output_conflict(out); end
+  def output_rule(out); end
+  def output_state(out); end
+  def output_token(out); end
+  def output_useless(out); end
+  def outrrconf(f, confs); end
+  def outsrconf(f, confs); end
+  def pointer_out(out, ptr); end
+  def symbol_locations(locs); end
+end
+
+class Racc::OrMark
+  def initialize(lineno); end
+
+  def inspect; end
+  def lineno; end
+  def name; end
+end
+
+class Racc::Parser
+  def _racc_do_parse_rb(arg, in_debug); end
+  def _racc_do_reduce(arg, act); end
+  def _racc_evalact(act, arg); end
+  def _racc_init_sysvars; end
+  def _racc_setup; end
+  def _racc_yyparse_rb(recv, mid, arg, c_debug); end
+  def do_parse; end
+  def next_token; end
+  def on_error(t, val, vstack); end
+  def racc_accept; end
+  def racc_e_pop(state, tstack, vstack); end
+  def racc_next_state(curstate, state); end
+  def racc_print_stacks(t, v); end
+  def racc_print_states(s); end
+  def racc_read_token(t, tok, val); end
+  def racc_reduce(toks, sim, tstack, vstack); end
+  def racc_shift(tok, tstack, vstack); end
+  def racc_token2str(tok); end
+  def token_to_str(t); end
+  def yyaccept; end
+  def yyerrok; end
+  def yyerror; end
+  def yyparse(recv, mid); end
+
+  class << self
+    def racc_runtime_type; end
+  end
+end
+
+Racc::Parser::Racc_Main_Parsing_Routine = T.let(T.unsafe(nil), Symbol)
+Racc::Parser::Racc_Runtime_Core_Id_C = T.let(T.unsafe(nil), String)
+Racc::Parser::Racc_Runtime_Core_Version = T.let(T.unsafe(nil), String)
+Racc::Parser::Racc_Runtime_Core_Version_C = T.let(T.unsafe(nil), String)
+Racc::Parser::Racc_Runtime_Core_Version_R = T.let(T.unsafe(nil), String)
+Racc::Parser::Racc_Runtime_Type = T.let(T.unsafe(nil), String)
+Racc::Parser::Racc_Runtime_Version = T.let(T.unsafe(nil), String)
+Racc::Parser::Racc_YY_Parse_Method = T.let(T.unsafe(nil), Symbol)
+
+class Racc::ParserClassGenerator
+  def initialize(states); end
+
+  def generate; end
+
+  private
+
+  def define_actions(c); end
+end
+
+class Racc::Prec
+  def initialize(symbol, lineno); end
+
+  def inspect; end
+  def lineno; end
+  def name; end
+  def symbol; end
+end
+
+class Racc::RRconflict
+  def initialize(sid, high, low, tok); end
+
+  def high_prec; end
+  def low_prec; end
+  def stateid; end
+  def to_s; end
+  def token; end
+end
+
+class Racc::Reduce
+  def initialize(rule); end
+
+  def decref; end
+  def incref; end
+  def inspect; end
+  def refn; end
+  def rule; end
+  def ruleid; end
+end
+
+class Racc::Rule
+  def initialize(target, syms, act); end
+
+  def ==(other); end
+  def [](idx); end
+  def accept?; end
+  def action; end
+  def each(&block); end
+  def each_rule(&block); end
+  def empty?; end
+  def hash; end
+  def hash=(n); end
+  def ident; end
+  def ident=(_arg0); end
+  def inspect; end
+  def null=(n); end
+  def nullable?; end
+  def prec(sym, &block); end
+  def precedence; end
+  def precedence=(sym); end
+  def ptrs; end
+  def replace(src, dest); end
+  def rule; end
+  def size; end
+  def specified_prec; end
+  def specified_prec=(_arg0); end
+  def symbols; end
+  def target; end
+  def target=(_arg0); end
+  def to_s; end
+  def useless=(u); end
+  def useless?; end
+  def |(x); end
+end
+
+class Racc::SRconflict
+  def initialize(sid, shift, reduce); end
+
+  def reduce; end
+  def shift; end
+  def stateid; end
+  def to_s; end
+end
+
+class Racc::Shift
+  def initialize(goto); end
+
+  def goto_id; end
+  def goto_state; end
+  def inspect; end
+end
+
+class Racc::SourceText
+  def initialize(text, filename, lineno); end
+
+  def filename; end
+  def lineno; end
+  def location; end
+  def text; end
+  def to_s; end
+end
+
+class Racc::State
+  def initialize(ident, core); end
+
+  def ==(oth); end
+  def action; end
+  def check_la(la_rules); end
+  def closure; end
+  def conflict?; end
+  def core; end
+  def defact; end
+  def defact=(_arg0); end
+  def eql?(oth); end
+  def goto_table; end
+  def gotos; end
+  def hash; end
+  def ident; end
+  def inspect; end
+  def la=(la); end
+  def make_closure(core); end
+  def n_rrconflicts; end
+  def n_srconflicts; end
+  def ritems; end
+  def rr_conflict(high, low, ctok); end
+  def rrconf; end
+  def rruleid(rule); end
+  def rrules; end
+  def sr_conflict(shift, reduce); end
+  def srconf; end
+  def stateid; end
+  def stokens; end
+  def to_s; end
+end
+
+class Racc::StateTransitionTable < ::Struct
+  def initialize(states); end
+
+  def action_check; end
+  def action_check=(_); end
+  def action_default; end
+  def action_default=(_); end
+  def action_pointer; end
+  def action_pointer=(_); end
+  def action_table; end
+  def action_table=(_); end
+  def debug_parser; end
+  def debug_parser=(_); end
+  def goto_check; end
+  def goto_check=(_); end
+  def goto_default; end
+  def goto_default=(_); end
+  def goto_pointer; end
+  def goto_pointer=(_); end
+  def goto_table; end
+  def goto_table=(_); end
+  def grammar; end
+  def nt_base; end
+  def nt_base=(_); end
+  def parser_class; end
+  def reduce_n; end
+  def reduce_n=(_); end
+  def reduce_table; end
+  def reduce_table=(_); end
+  def shift_n; end
+  def shift_n=(_); end
+  def states; end
+  def token_table; end
+  def token_table=(_); end
+  def token_to_s_table; end
+  def token_to_s_table=(_); end
+  def token_value_table; end
+  def use_result_var; end
+  def use_result_var=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def generate(states); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class Racc::StateTransitionTableGenerator
+  def initialize(states); end
+
+  def act2actid(act); end
+  def addent(all, arr, chkval, ptr); end
+  def gen_action_tables(t, states); end
+  def gen_goto_tables(t, grammar); end
+  def generate; end
+  def mkmapexp(arr); end
+  def reduce_table(grammar); end
+  def set_table(entries, dummy, tbl, chk, ptr); end
+  def token_table(grammar); end
+end
+
+Racc::StateTransitionTableGenerator::RE_DUP_MAX = T.let(T.unsafe(nil), Integer)
+
+class Racc::States
+  include ::Enumerable
+  extend ::Forwardable
+
+  def initialize(grammar, debug_flags = T.unsafe(nil)); end
+
+  def [](i); end
+  def actions; end
+  def dfa; end
+  def each(&block); end
+  def each_index(&block); end
+  def each_state(&block); end
+  def grammar; end
+  def inspect; end
+  def n_rrconflicts; end
+  def n_srconflicts; end
+  def nfa; end
+  def nt_base(*args, &block); end
+  def reduce_n(*args, &block); end
+  def rrconflict_exist?; end
+  def shift_n(*args, &block); end
+  def should_report_srconflict?; end
+  def size; end
+  def srconflict_exist?; end
+  def state_transition_table; end
+  def to_s; end
+
+  private
+
+  def addrel(tbl, i, item); end
+  def addsym(table, sym, ptr); end
+  def check_useless; end
+  def compute_dfa; end
+  def compute_nfa; end
+  def core_to_state(core); end
+  def create_tmap(size); end
+  def digraph(map, relation); end
+  def do_resolve_sr(stok, rtok); end
+  def each_t(tbl, set); end
+  def fingerprint(arr); end
+  def generate_states(state); end
+  def lookahead; end
+  def pack(state); end
+  def print_atab(idx, tab); end
+  def print_tab(idx, rel, tab); end
+  def print_tab_i(idx, rel, tab, i); end
+  def printb(i); end
+  def record_path(begst, rule); end
+  def resolve(state); end
+  def resolve_rr(state, r); end
+  def resolve_sr(state, s); end
+  def set_accept; end
+  def transpose(rel); end
+  def traverse(i, index, vertices, map, relation); end
+end
+
+Racc::States::ASSOC = T.let(T.unsafe(nil), Hash)
+
+class Racc::Sym
+  def initialize(value, dummyp); end
+
+  def assoc; end
+  def assoc=(_arg0); end
+  def dummy?; end
+  def expand; end
+  def expand=(v); end
+  def hash; end
+  def heads; end
+  def ident; end
+  def ident=(v); end
+  def inspect; end
+  def locate; end
+  def nonterminal?; end
+  def null=(n); end
+  def nullable?; end
+  def precedence; end
+  def precedence=(_arg0); end
+  def rule; end
+  def self_null?; end
+  def serialize; end
+  def serialized=(_arg0); end
+  def should_terminal; end
+  def should_terminal?; end
+  def snull=(v); end
+  def string_symbol?; end
+  def term=(t); end
+  def terminal?; end
+  def to_s; end
+  def useless=(f); end
+  def useless?; end
+  def value; end
+  def |(x); end
+
+  class << self
+    def once_writer(nm); end
+  end
+end
+
+class Racc::SymbolTable
+  include ::Enumerable
+
+  def initialize; end
+
+  def [](id); end
+  def anchor; end
+  def delete(sym); end
+  def dummy; end
+  def each(&block); end
+  def each_nonterminal(&block); end
+  def each_terminal(&block); end
+  def error; end
+  def fix; end
+  def intern(val, dummy = T.unsafe(nil)); end
+  def nonterminals; end
+  def nt_base; end
+  def nt_max; end
+  def symbols; end
+  def terminals(&block); end
+  def to_a; end
+
+  private
+
+  def check_terminals; end
+  def fix_ident; end
+end
+
+class Racc::UserAction
+  def initialize(src, proc); end
+
+  def empty?; end
+  def inspect; end
+  def name; end
+  def proc; end
+  def proc?; end
+  def source; end
+  def source?; end
+
+  class << self
+    def empty; end
+    def proc(pr = T.unsafe(nil), &block); end
+    def source_text(src); end
+  end
+end
+
+Racc::VERSION = T.let(T.unsafe(nil), String)
+Racc::Version = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi

@@ -5134,6 +5134,10 @@ class Object
   include ::Minitest::Expectations
   include ::SystemCommand::Mixin
   include ::Utils::Curl
+  def __send(*arg); end
+
+  def __send!(*arg); end
+
   def deep_dup(); end
 
   def duplicable?(); end
@@ -5373,8 +5377,6 @@ class Parlour::Types::Type
   extend ::T::InterfaceWrapper::Helpers
 end
 
-ParseError = Racc::ParseError
-
 class Parser::Ruby26
   Racc_debug_parser = ::T.let(nil, ::T.untyped)
 end
@@ -5603,21 +5605,6 @@ end
 class Racc::CparseParams
 end
 
-class Racc::Parser
-  Racc_Main_Parsing_Routine = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Core_Id_C = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Core_Revision = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Core_Revision_C = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Core_Revision_R = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Core_Version = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Core_Version_C = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Core_Version_R = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Revision = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Type = ::T.let(nil, ::T.untyped)
-  Racc_Runtime_Version = ::T.let(nil, ::T.untyped)
-  Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped)
-end
-
 class Random
   def self.bytes(arg); end
 end

Library/Homebrew/vendor/bundle/bundler/setup.rb

@@ -63,7 +63,9 @@ $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version
 $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/mustache-1.1.1/lib")
 $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parallel-1.23.0/lib")
 $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parallel_tests-3.13.0/lib")
-$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parser-3.2.2.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/universal-darwin-22/#{Gem.extension_api_version}/racc-1.7.1")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/racc-1.7.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parser-3.2.2.3/lib")
 $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rainbow-3.1.1/lib")
 $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/sorbet-runtime-0.5.10461/lib")
 $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parlour-8.1.0/lib")