diff --git a/Gemfile.lock b/Gemfile.lock index 804b4817..a3305277 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -2,10 +2,8 @@ PATH remote: . specs: rbi (0.0.17) - ast - parser (>= 3.0.0) sorbet-runtime (>= 0.5.9204) - unparser (>= 0.5.6) + yarp (>= 0.10.0) GEM remote: https://rubygems.org/ @@ -15,7 +13,6 @@ GEM base64 (0.1.1) builder (3.2.4) byebug (11.1.3) - diff-lcs (1.5.0) json (2.6.3) language_server-protocol (3.17.0.3) minitest (5.19.0) @@ -57,6 +54,7 @@ GEM sorbet-static (= 0.5.10993) sorbet-runtime (0.5.10993) sorbet-static (0.5.10993-universal-darwin-21) + sorbet-static (0.5.10993-universal-darwin-22) sorbet-static (0.5.10993-x86_64-linux) sorbet-static-and-runtime (0.5.10993) sorbet (= 0.5.10993) @@ -76,16 +74,15 @@ GEM yard-sorbet thor (1.2.2) unicode-display_width (2.4.2) - unparser (0.6.8) - diff-lcs (~> 1.3) - parser (>= 3.2.0) yard (0.9.34) yard-sorbet (0.8.1) sorbet-runtime (>= 0.5) yard (>= 0.9) + yarp (0.10.0) PLATFORMS arm64-darwin-21 + arm64-darwin-22 x86_64-linux DEPENDENCIES diff --git a/lib/rbi/loc.rb b/lib/rbi/loc.rb index 2e217092..49c2ab93 100644 --- a/lib/rbi/loc.rb +++ b/lib/rbi/loc.rb @@ -5,6 +5,21 @@ module RBI class Loc extend T::Sig + class << self + extend T::Sig + + sig { params(file: String, yarp_location: YARP::Location).returns(Loc) } + def from_yarp(file, yarp_location) + new( + file: file, + begin_line: yarp_location.start_line, + end_line: yarp_location.end_line, + begin_column: yarp_location.start_column, + end_column: yarp_location.end_column + 1, # TODO: Why is this off by one? + ) + end + end + sig { returns(T.nilable(String)) } attr_reader :file diff --git a/lib/rbi/parser.rb b/lib/rbi/parser.rb index 09c7979f..9bc3114a 100644 --- a/lib/rbi/parser.rb +++ b/lib/rbi/parser.rb @@ -1,7 +1,7 @@ # typed: strict # frozen_string_literal: true -require "parser" +require "yarp" module RBI class ParseError < StandardError @@ -53,19 +53,6 @@ def print_debug(io: $stderr) class Parser extend T::Sig - # opt-in to most recent AST format - ::Parser::Builders::Default.emit_lambda = true - ::Parser::Builders::Default.emit_procarg0 = true - ::Parser::Builders::Default.emit_encoding = true - ::Parser::Builders::Default.emit_index = true - ::Parser::Builders::Default.emit_arg_inside_procarg0 = true - - sig { void } - def initialize - # Delay load unparser and only if it has not been loaded already. - require "unparser" unless defined?(::Unparser) - end - class << self extend T::Sig @@ -104,22 +91,24 @@ def parse_file(path) private - sig { params(content: String, file: String).returns(Tree) } - def parse(content, file:) - node, comments = Unparser.parse_with_comments(content) - assoc = ::Parser::Source::Comment.associate_locations(node, comments) - builder = TreeBuilder.new(file: file, comments: comments, nodes_comments_assoc: assoc) - builder.visit(node) - builder.post_process - builder.tree - rescue ::Parser::SyntaxError => e - raise ParseError.new(e.message, Loc.from_ast_loc(file, e.diagnostic.location)) + sig { params(source: String, file: String).returns(Tree) } + def parse(source, file:) + result = YARP.parse(source) + unless result.success? + raise ParseError.new(result.errors.map(&:message).join(" "), Loc.from_yarp(file, result.errors.first.location)) + end + + visitor = TreeBuilder.new(source, comments: result.comments, file: file) + visitor.visit(result.value) + visitor.tree + rescue YARP::ParseError => e + raise ParseError.new(e.message, Loc.from_yarp(file, e.location)) rescue ParseError => e raise e rescue => e - last_node = builder&.last_node + last_node = visitor&.last_node last_location = if last_node - Loc.from_ast_loc(file, last_node.location) + Loc.from_yarp(file, last_node.location) else Loc.new(file: file) end @@ -128,630 +117,692 @@ def parse(content, file:) exception.print_debug raise exception end - end - class ASTVisitor - extend T::Helpers - extend T::Sig + class Visitor < YARP::Visitor + extend T::Sig - abstract! + sig { params(source: String, file: String).void } + def initialize(source, file:) + super() - sig { params(nodes: T::Array[AST::Node]).void } - def visit_all(nodes) - nodes.each { |node| visit(node) } - end + @source = source + @file = file + end - sig { abstract.params(node: T.nilable(AST::Node)).void } - def visit(node); end + private - private + sig { params(node: YARP::Node).returns(Loc) } + def node_loc(node) + Loc.from_yarp(@file, node.location) + end - sig { params(node: AST::Node).returns(String) } - def parse_name(node) - T.must(ConstBuilder.visit(node)) - end + sig { params(node: T.nilable(YARP::Node)).returns(T.nilable(String)) } + def node_string(node) + return unless node - sig { params(node: AST::Node).returns(String) } - def parse_expr(node) - Unparser.unparse(node) + node.slice + end + + sig { params(node: YARP::Node).returns(String) } + def node_string!(node) + T.must(node_string(node)) + end end - end - class TreeBuilder < ASTVisitor - extend T::Sig + class TreeBuilder < Visitor + extend T::Sig - sig { returns(Tree) } - attr_reader :tree + sig { returns(Tree) } + attr_reader :tree - sig { returns(T.nilable(::AST::Node)) } - attr_reader :last_node + sig { returns(T.nilable(YARP::Node)) } + attr_reader :last_node - sig do - params( - file: String, - comments: T::Array[::Parser::Source::Comment], - nodes_comments_assoc: T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]], - ).void - end - def initialize(file:, comments: [], nodes_comments_assoc: {}) - super() - @file = file - @comments = comments - @nodes_comments_assoc = nodes_comments_assoc - @tree = T.let(Tree.new, Tree) - @scopes_stack = T.let([@tree], T::Array[Tree]) - @last_node = T.let(nil, T.nilable(::AST::Node)) - @last_sigs = T.let([], T::Array[RBI::Sig]) - @last_sigs_comments = T.let([], T::Array[Comment]) - - separate_header_comments - end + sig { params(source: String, comments: T::Array[YARP::Comment], file: String).void } + def initialize(source, comments:, file:) + super(source, file: file) - sig { void } - def post_process - assoc_dangling_comments - set_root_tree_loc - end + @comments_by_line = T.let(comments.to_h { |c| [c.location.start_line, c] }, T::Hash[Integer, YARP::Comment]) + @tree = T.let(Tree.new, Tree) + + @scopes_stack = T.let([@tree], T::Array[Tree]) + @last_node = T.let(nil, T.nilable(YARP::Node)) + @last_sigs = T.let([], T::Array[RBI::Sig]) + @last_sigs_comments = T.let([], T::Array[Comment]) + end + + sig { override.params(node: T.nilable(YARP::Node)).void } + def visit(node) + return unless node - sig { override.params(node: T.nilable(Object)).void } - def visit(node) - return unless node.is_a?(AST::Node) + @last_node = node + super + end - @last_node = node + sig { override.params(node: YARP::ClassNode).void } + def visit_class_node(node) + scope = Class.new( + node_string!(node.constant_path), + superclass_name: node_string(node.superclass), + loc: node_loc(node), + comments: node_comments(node), + ) - case node.type - when :module, :class, :sclass - scope = parse_scope(node) current_scope << scope @scopes_stack << scope - visit_all(node.children) + visit(node.body) + collect_dangling_comments(node) @scopes_stack.pop - when :casgn - current_scope << parse_const_assign(node) - when :def, :defs - current_scope << parse_def(node) - when :send - node = parse_send(node) - current_scope << node if node - when :block - rbi_node = parse_block(node) - if rbi_node.is_a?(Sig) - @last_sigs << rbi_node - @last_sigs_comments.concat(node_comments(node)) - elsif rbi_node - current_scope << rbi_node - end - else - visit_all(node.children) end - @last_node = nil - end - - private - - sig { params(node: AST::Node).returns(Scope) } - def parse_scope(node) - loc = node_loc(node) - comments = node_comments(node) - - case node.type - when :module - name = parse_name(node.children[0]) - Module.new(name, loc: loc, comments: comments) - when :class - name = parse_name(node.children[0]) - superclass_name = ConstBuilder.visit(node.children[1]) - Class.new(name, superclass_name: superclass_name, loc: loc, comments: comments) - when :sclass - SingletonClass.new(loc: loc, comments: comments) - else - raise ParseError.new("Unsupported scope node type `#{node.type}`", loc) + sig { override.params(node: YARP::ConstantWriteNode).void } + def visit_constant_write_node(node) + visit_constant_assign(node) end - end - sig { params(node: AST::Node).returns(RBI::Node) } - def parse_const_assign(node) - node_value = node.children[2] - if struct_definition?(node_value) - parse_struct(node) - elsif type_variable_definition?(node_value) - parse_type_variable(node) - else - name = parse_name(node) - value = parse_expr(node_value) - loc = node_loc(node) - comments = node_comments(node) - Const.new(name, value, loc: loc, comments: comments) + sig { override.params(node: YARP::ConstantPathWriteNode).void } + def visit_constant_path_write_node(node) + visit_constant_assign(node) end - end - sig { params(node: AST::Node).returns(Method) } - def parse_def(node) - loc = node_loc(node) + sig { params(node: T.any(YARP::ConstantWriteNode, YARP::ConstantPathWriteNode)).void } + def visit_constant_assign(node) + struct = parse_struct(node) + + current_scope << if struct + struct + elsif type_variable_definition?(node.value) + TypeMember.new( + case node + when YARP::ConstantWriteNode + node.name + when YARP::ConstantPathWriteNode + node_string!(node.target) + end, + node_string!(node.value), + loc: node_loc(node), + comments: node_comments(node), + ) + else + Const.new( + case node + when YARP::ConstantWriteNode + node.name + when YARP::ConstantPathWriteNode + node_string!(node.target) + end, + node_string!(node.value), + loc: node_loc(node), + comments: node_comments(node), + ) + end + end - case node.type - when :def - Method.new( - node.children[0].to_s, - params: node.children[1].children.map { |child| parse_param(child) }, + sig { override.params(node: YARP::DefNode).void } + def visit_def_node(node) + current_scope << Method.new( + node.name, + params: parse_params(node.parameters), sigs: current_sigs, - loc: loc, + loc: node_loc(node), comments: current_sigs_comments + node_comments(node), + is_singleton: !!node.receiver, ) - when :defs - Method.new( - node.children[1].to_s, - params: node.children[2].children.map { |child| parse_param(child) }, - is_singleton: true, - sigs: current_sigs, - loc: loc, - comments: current_sigs_comments + node_comments(node), + end + + sig { override.params(node: YARP::ModuleNode).void } + def visit_module_node(node) + scope = Module.new( + node_string!(node.constant_path), + loc: node_loc(node), + comments: node_comments(node), ) - else - raise ParseError.new("Unsupported def node type `#{node.type}`", loc) + + current_scope << scope + @scopes_stack << scope + visit(node.body) + collect_dangling_comments(node) + @scopes_stack.pop end - end - sig { params(node: AST::Node).returns(Param) } - def parse_param(node) - name = node.children[0].to_s - loc = node_loc(node) - comments = node_comments(node) - - case node.type - when :arg - ReqParam.new(name, loc: loc, comments: comments) - when :optarg - value = parse_expr(node.children[1]) - OptParam.new(name, value, loc: loc, comments: comments) - when :restarg - RestParam.new(name, loc: loc, comments: comments) - when :kwarg - KwParam.new(name, loc: loc, comments: comments) - when :kwoptarg - value = parse_expr(node.children[1]) - KwOptParam.new(name, value, loc: loc, comments: comments) - when :kwrestarg - KwRestParam.new(name, loc: loc, comments: comments) - when :blockarg - BlockParam.new(name, loc: loc, comments: comments) - else - raise ParseError.new("Unsupported param node type `#{node.type}`", loc) + sig { override.params(node: YARP::ProgramNode).void } + def visit_program_node(node) + super + + collect_orphan_comments + separate_header_comments + set_root_tree_loc end - end - sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) } - def parse_send(node) - recv = node.children[0] - return if recv && recv != :self - - method_name = node.children[1] - loc = node_loc(node) - comments = node_comments(node) - - case method_name - when :attr_reader - symbols = node.children[2..-1].map { |child| child.children[0] } - AttrReader.new(*symbols, sigs: current_sigs, loc: loc, comments: current_sigs_comments + comments) - when :attr_writer - symbols = node.children[2..-1].map { |child| child.children[0] } - AttrWriter.new(*symbols, sigs: current_sigs, loc: loc, comments: current_sigs_comments + comments) - when :attr_accessor - symbols = node.children[2..-1].map { |child| child.children[0] } - AttrAccessor.new(*symbols, sigs: current_sigs, loc: loc, comments: current_sigs_comments + comments) - when :include - names = node.children[2..-1].map { |child| parse_expr(child) } - Include.new(*names, loc: loc, comments: comments) - when :extend - names = node.children[2..-1].map { |child| parse_expr(child) } - Extend.new(*names, loc: loc, comments: comments) - when :abstract!, :sealed!, :interface! - Helper.new(method_name.to_s.delete_suffix("!"), loc: loc, comments: comments) - when :mixes_in_class_methods - names = node.children[2..-1].map { |child| parse_name(child) } - MixesInClassMethods.new(*names, loc: loc, comments: comments) - when :public, :protected, :private - visibility = case method_name - when :protected - Protected.new(loc: loc) - when :private - Private.new(loc: loc) - else - Public.new(loc: loc) - end - nested_node = node.children[2] - case nested_node&.type - when :def, :defs - method = parse_def(nested_node) - method.visibility = visibility - method - when :send - snode = parse_send(nested_node) - raise ParseError.new("Unexpected token `private` before `#{nested_node.type}`", loc) unless snode.is_a?(Attr) - - snode.visibility = visibility - snode - when nil - visibility - else - raise ParseError.new("Unexpected token `private` before `#{nested_node.type}`", loc) - end - when :prop - name, type, default_value = parse_tstruct_prop(node) - TStructProp.new(name, type, default: default_value, loc: loc, comments: comments) - when :const - name, type, default_value = parse_tstruct_prop(node) - TStructConst.new(name, type, default: default_value, loc: loc, comments: comments) - else - args = parse_send_args(node) - Send.new(method_name.to_s, args, loc: loc, comments: comments) + sig { override.params(node: YARP::SingletonClassNode).void } + def visit_singleton_class_node(node) + scope = SingletonClass.new( + loc: node_loc(node), + comments: node_comments(node), + ) + + current_scope << scope + @scopes_stack << scope + visit(node.body) + collect_dangling_comments(node) + @scopes_stack.pop end - end - sig { params(node: AST::Node).returns(T::Array[Arg]) } - def parse_send_args(node) - args = T.let([], T::Array[Arg]) - node.children[2..-1].each do |child| - if child.type == :kwargs - child.children.each do |pair| - keyword = pair.children.first.children.last.to_s - value = parse_expr(pair.children.last) - args << KwArg.new(keyword, value) + sig { params(node: YARP::CallNode).void } + def visit_call_node(node) + message = node.name + case message + when "abstract!", "sealed!", "interface!" + current_scope << Helper.new( + message.delete_suffix("!"), + loc: node_loc(node), + comments: node_comments(node), + ) + when "attr_reader" + args = node.arguments + return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any? + + current_scope << AttrReader.new( + *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }), + sigs: current_sigs, + loc: node_loc(node), + comments: current_sigs_comments + node_comments(node), + ) + when "attr_writer" + args = node.arguments + return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any? + + current_scope << AttrWriter.new( + *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }), + sigs: current_sigs, + loc: node_loc(node), + comments: current_sigs_comments + node_comments(node), + ) + when "attr_accessor" + args = node.arguments + return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any? + + current_scope << AttrAccessor.new( + *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }), + sigs: current_sigs, + loc: node_loc(node), + comments: current_sigs_comments + node_comments(node), + ) + when "enums" + block = node.block + return unless block.is_a?(YARP::BlockNode) + + body = block.body + return unless body.is_a?(YARP::StatementsNode) + + current_scope << TEnumBlock.new( + body.body.map { |stmt| T.cast(stmt, YARP::ConstantWriteNode).name }, + loc: node_loc(node), + comments: node_comments(node), + ) + when "extend" + args = node.arguments + return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any? + + current_scope << Extend.new( + *T.unsafe(args.arguments.map { |arg| node_string!(arg) }), + loc: node_loc(node), + comments: node_comments(node), + ) + when "include" + args = node.arguments + return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any? + + current_scope << Include.new( + *T.unsafe(args.arguments.map { |arg| node_string!(arg) }), + loc: node_loc(node), + comments: node_comments(node), + ) + when "mixes_in_class_methods" + args = node.arguments + return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any? + + current_scope << MixesInClassMethods.new( + *T.unsafe(args.arguments.map { |arg| node_string!(arg) }), + loc: node_loc(node), + comments: node_comments(node), + ) + when "private", "protected", "public" + args = node.arguments + if args.is_a?(YARP::ArgumentsNode) && args.arguments.any? + visit(node.arguments) + last_node = @scopes_stack.last&.nodes&.last + case last_node + when Method, Attr + last_node.visibility = parse_visibility(node.name, node) + else + raise ParseError.new( + "Unexpected token `#{node.message}` before `#{last_node&.string&.strip}`", + node_loc(node), + ) + end + else + current_scope << parse_visibility(node.name, node) end + when "prop", "const" + parse_tstruct_field(node) + when "requires_ancestor" + block = node.block + return unless block.is_a?(YARP::BlockNode) + + body = block.body + return unless body.is_a?(YARP::StatementsNode) + + current_scope << RequiresAncestor.new( + node_string!(body), + loc: node_loc(node), + comments: node_comments(node), + ) + when "sig" + @last_sigs << parse_sig(node) else - args << Arg.new(parse_expr(child)) + current_scope << Send.new( + message, + parse_send_args(node.arguments), + loc: node_loc(node), + comments: node_comments(node), + ) end end - args - end - sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) } - def parse_block(node) - name = node.children[0].children[1] - - case name - when :sig - parse_sig(node) - when :enums - parse_enum(node) - when :requires_ancestor - parse_requires_ancestor(node) - else - raise ParseError.new("Unsupported block node type `#{name}`", node_loc(node)) - end - end + private - sig { params(node: AST::Node).returns(T::Boolean) } - def struct_definition?(node) - (node.type == :send && node.children[0]&.type == :const && node.children[0].children[1] == :Struct) || - (node.type == :block && struct_definition?(node.children[0])) - end + # Collect all the remaining comments within a node + sig { params(node: YARP::Node).void } + def collect_dangling_comments(node) + first_line = node.location.start_line + last_line = node.location.end_line - sig { params(node: AST::Node).returns(RBI::Struct) } - def parse_struct(node) - name = parse_name(node) - loc = node_loc(node) - comments = node_comments(node) + last_node_last_line = node.child_nodes.last&.location&.end_line - send = node.children[2] - body = [] + last_line.downto(first_line) do |line| + comment = @comments_by_line[line] + next unless comment + break if last_node_last_line && line <= last_node_last_line - if send.type == :block - if send.children[2].type == :begin - body = send.children[2].children - else - body << send.children[2] + current_scope << parse_comment(comment) + @comments_by_line.delete(line) end - send = send.children[0] - end - - members = [] - keyword_init = T.let(false, T::Boolean) - send.children[2..].each do |child| - if child.type == :sym - members << child.children[0] - elsif child.type == :kwargs - pair = child.children[0] - if pair.children[0].children[0] == :keyword_init - keyword_init = true if pair.children[1].type == :true + end + + # Collect all the remaining comments after visiting the tree + sig { void } + def collect_orphan_comments + last_line = T.let(nil, T.nilable(Integer)) + last_node_end = @tree.nodes.last&.loc&.end_line + + @comments_by_line.each do |line, comment| + # Associate the comment either with the header or the file or as a dangling comment at the end + recv = if last_node_end && line >= last_node_end + @tree + else + @tree.comments end + + # Preserve blank lines in comments + if last_line && line > last_line + 1 + recv << BlankLine.new(loc: Loc.from_yarp(@file, comment.location)) + end + + recv << parse_comment(comment) + last_line = line end end - struct = Struct.new(name, members: members, keyword_init: keyword_init, loc: loc, comments: comments) - @scopes_stack << struct - visit_all(body) - @scopes_stack.pop - - struct - end + sig { returns(Tree) } + def current_scope + T.must(@scopes_stack.last) # Should never be nil since we create a Tree as the root + end - sig { params(node: AST::Node).returns(T::Boolean) } - def type_variable_definition?(node) - (node.type == :send && node.children[0].nil? && (node.children[1] == :type_member || - node.children[1] == :type_template)) || - (node.type == :block && type_variable_definition?(node.children[0])) - end + sig { returns(T::Array[Sig]) } + def current_sigs + sigs = @last_sigs.dup + @last_sigs.clear + sigs + end - sig { params(node: AST::Node).returns(RBI::TypeMember) } - def parse_type_variable(node) - name = parse_name(node) - loc = node_loc(node) - comments = node_comments(node) + sig { returns(T::Array[Comment]) } + def current_sigs_comments + comments = @last_sigs_comments.dup + @last_sigs_comments.clear + comments + end - send = node.children[2] + sig { params(node: YARP::Node).returns(T::Array[Comment]) } + def node_comments(node) + comments = [] - TypeMember.new(name, send.location.expression.source, loc: loc, comments: comments) - end + start_line = node.location.start_line + start_line -= 1 unless @comments_by_line.key?(start_line) - sig { params(node: AST::Node).returns([String, String, T.nilable(String)]) } - def parse_tstruct_prop(node) - name = node.children[2].children[0].to_s - type = parse_expr(node.children[3]) - has_default = node.children[4] - &.children&.fetch(0, nil) - &.children&.fetch(0, nil) - &.children&.fetch(0, nil) == :default - default_value = if has_default - parse_expr(node.children.fetch(4, nil) - &.children&.fetch(0, nil) - &.children&.fetch(1, nil)) - end - [name, type, default_value] - end + start_line.downto(1) do |line| + comment = @comments_by_line[line] + break unless comment - sig { params(node: AST::Node).returns(Sig) } - def parse_sig(node) - sig = SigBuilder.build(node) - sig.loc = node_loc(node) - sig - end + comments.unshift(parse_comment(comment)) + @comments_by_line.delete(line) + end - sig { params(node: AST::Node).returns(TEnumBlock) } - def parse_enum(node) - enum = TEnumBlock.new + comments + end - body = if node.children[2].type == :begin - node.children[2].children - else - [node.children[2]] + sig { params(node: YARP::Comment).returns(Comment) } + def parse_comment(node) + Comment.new(node.location.slice.gsub(/^# ?/, "").rstrip, loc: Loc.from_yarp(@file, node.location)) end - body.each do |child| - enum << parse_name(child) + sig { params(node: T.nilable(YARP::Node)).returns(T::Array[Arg]) } + def parse_send_args(node) + args = T.let([], T::Array[Arg]) + return args unless node.is_a?(YARP::ArgumentsNode) + + node.arguments.each do |arg| + case arg + when YARP::KeywordHashNode + arg.elements.each do |assoc| + next unless assoc.is_a?(YARP::AssocNode) + + args << KwArg.new( + node_string!(assoc.key).delete_suffix(":"), + T.must(node_string(assoc.value)), + ) + end + else + args << Arg.new(T.must(node_string(arg))) + end + end + + args end - enum.loc = node_loc(node) - enum - end - sig { params(node: AST::Node).returns(RequiresAncestor) } - def parse_requires_ancestor(node) - name = parse_name(node.children[2]) - ra = RequiresAncestor.new(name) - ra.loc = node_loc(node) - ra - end + sig { params(node: T.nilable(YARP::Node)).returns(T::Array[Param]) } + def parse_params(node) + params = [] + return params unless node.is_a?(YARP::ParametersNode) - sig { params(node: AST::Node).returns(Loc) } - def node_loc(node) - Loc.from_ast_loc(@file, node.location) - end + node.requireds.each do |param| + next unless param.is_a?(YARP::RequiredParameterNode) - sig { params(node: AST::Node).returns(T::Array[Comment]) } - def node_comments(node) - comments = @nodes_comments_assoc[node.location] - return [] unless comments + params << ReqParam.new( + param.name.to_s, + loc: node_loc(param), + comments: node_comments(param), + ) + end - comments.map do |comment| - text = comment.text[1..-1].strip - loc = Loc.from_ast_loc(@file, comment.location) - Comment.new(text, loc: loc) - end - end + node.optionals.each do |param| + next unless param.is_a?(YARP::OptionalParameterNode) - sig { returns(Tree) } - def current_scope - T.must(@scopes_stack.last) # Should never be nil since we create a Tree as the root - end + params << OptParam.new( + param.name.to_s, + node_string!(param.value), + loc: node_loc(param), + comments: node_comments(param), + ) + end - sig { returns(T::Array[Sig]) } - def current_sigs - sigs = @last_sigs.dup - @last_sigs.clear - sigs - end + rest = node.rest + if rest.is_a?(YARP::RestParameterNode) + params << RestParam.new( + rest.name || "*args", + loc: node_loc(rest), + comments: node_comments(rest), + ) + end - sig { returns(T::Array[Comment]) } - def current_sigs_comments - comments = @last_sigs_comments.dup - @last_sigs_comments.clear - comments - end + node.keywords.each do |param| + next unless param.is_a?(YARP::KeywordParameterNode) + + value = param.value + params << if value + KwOptParam.new( + param.name.delete_suffix(":"), + node_string!(value), + loc: node_loc(param), + comments: node_comments(param), + ) + else + KwParam.new( + param.name.delete_suffix(":"), + loc: node_loc(param), + comments: node_comments(param), + ) + end + end - sig { void } - def assoc_dangling_comments - last_line = T.let(nil, T.nilable(Integer)) - (@comments - @nodes_comments_assoc.values.flatten).each do |comment| - comment_line = comment.location.last_line - text = comment.text[1..-1].strip - loc = Loc.from_ast_loc(@file, comment.location) - - if last_line && comment_line > last_line + 1 - # Preserve empty lines in file headers - tree.comments << BlankLine.new(loc: loc) + rest_kw = node.keyword_rest + if rest_kw.is_a?(YARP::KeywordRestParameterNode) + params << KwRestParam.new( + rest_kw.name || "**kwargs", + loc: node_loc(rest_kw), + comments: node_comments(rest_kw), + ) end - tree.comments << Comment.new(text, loc: loc) - last_line = comment_line + block = node.block + if block.is_a?(YARP::BlockParameterNode) + params << BlockParam.new( + block.name || "&block", + loc: node_loc(block), + comments: node_comments(block), + ) + end + + params end - end - sig { void } - def separate_header_comments - return if @nodes_comments_assoc.empty? + sig { params(node: YARP::CallNode).returns(Sig) } + def parse_sig(node) + @last_sigs_comments = node_comments(node) - keep = [] - node = T.must(@nodes_comments_assoc.keys.first) - comments = T.must(@nodes_comments_assoc.values.first) + builder = SigBuilder.new(@source, file: @file) + builder.current.loc = node_loc(node) + builder.visit_call_node(node) + builder.current + end - last_line = T.let(nil, T.nilable(Integer)) - comments.reverse.each do |comment| - comment_line = comment.location.last_line + sig { params(node: T.any(YARP::ConstantWriteNode, YARP::ConstantPathWriteNode)).returns(T.nilable(Struct)) } + def parse_struct(node) + send = node.value + return unless send.is_a?(YARP::CallNode) + return unless send.message == "new" + + recv = send.receiver + return unless recv + return unless node_string(recv) =~ /(::)?Struct/ + + members = [] + keyword_init = T.let(false, T::Boolean) + + args = send.arguments + if args.is_a?(YARP::ArgumentsNode) + args.arguments.each do |arg| + case arg + when YARP::SymbolNode + members << arg.value + when YARP::KeywordHashNode + arg.elements.each do |assoc| + next unless assoc.is_a?(YARP::AssocNode) + + key = node_string!(assoc.key) + val = node_string(assoc.value) + + keyword_init = val == "true" if key == "keyword_init:" + end + else + raise ParseError.new("Unexpected node type `#{arg.class}`", node_loc(arg)) + end + end + end - break if last_line && comment_line < last_line - 1 || - !last_line && comment_line < node.first_line - 1 + name = case node + when YARP::ConstantWriteNode + node.name + when YARP::ConstantPathWriteNode + node_string!(node.target) + end - keep << comment - last_line = comment_line + loc = node_loc(node) + comments = node_comments(node) + struct = Struct.new(name, members: members, keyword_init: keyword_init, loc: loc, comments: comments) + @scopes_stack << struct + visit(send.block) + @scopes_stack.pop + struct end - @nodes_comments_assoc[node] = keep.reverse - end + sig { params(send: YARP::CallNode).void } + def parse_tstruct_field(send) + args = send.arguments + return unless args.is_a?(YARP::ArgumentsNode) - sig { void } - def set_root_tree_loc - first_loc = tree.nodes.first&.loc - last_loc = tree.nodes.last&.loc - - @tree.loc = Loc.new( - file: @file, - begin_line: first_loc&.begin_line || 0, - begin_column: first_loc&.begin_column || 0, - end_line: last_loc&.end_line || 0, - end_column: last_loc&.end_column || 0, - ) - end - end + name_arg, type_arg, *rest = args.arguments + return unless name_arg + return unless type_arg - class ConstBuilder < ASTVisitor - extend T::Sig + name = node_string!(name_arg).delete_prefix(":") + type = node_string!(type_arg) + loc = node_loc(send) + comments = node_comments(send) + default_value = T.let(nil, T.nilable(String)) - sig { returns(T::Array[String]) } - attr_accessor :names + rest&.each do |arg| + next unless arg.is_a?(YARP::KeywordHashNode) - sig { void } - def initialize - super - @names = T.let([], T::Array[String]) - end + arg.elements.each do |assoc| + next unless assoc.is_a?(YARP::AssocNode) - class << self - extend T::Sig + if node_string(assoc.key) == "default:" + default_value = node_string(assoc.value) + end + end + end - sig { params(node: T.nilable(AST::Node)).returns(T.nilable(String)) } - def visit(node) - v = ConstBuilder.new - v.visit(node) - return if v.names.empty? + current_scope << case send.message + when "const" + TStructConst.new(name, type, default: default_value, loc: loc, comments: comments) + when "prop" + TStructProp.new(name, type, default: default_value, loc: loc, comments: comments) + else + raise ParseError.new("Unexpected message `#{send.message}`", loc) + end + end - v.names.join("::") + sig { params(name: String, node: YARP::Node).returns(Visibility) } + def parse_visibility(name, node) + case name + when "public" + Public.new(loc: node_loc(node)) + when "protected" + Protected.new(loc: node_loc(node)) + when "private" + Private.new(loc: node_loc(node)) + else + raise ParseError.new("Unexpected visibility `#{name}`", node_loc(node)) + end end - end - sig { override.params(node: T.nilable(AST::Node)).void } - def visit(node) - return unless node + sig { void } + def separate_header_comments + current_scope.nodes.dup.each do |child_node| + break unless child_node.is_a?(Comment) || child_node.is_a?(BlankLine) - case node.type - when :const, :casgn - visit(node.children[0]) - @names << node.children[1].to_s - when :cbase - @names << "" - when :sym - @names << ":#{node.children[0]}" + current_scope.comments << child_node + child_node.detach + end end - end - end - class SigBuilder < ASTVisitor - extend T::Sig + sig { void } + def set_root_tree_loc + first_loc = tree.nodes.first&.loc + last_loc = tree.nodes.last&.loc + + @tree.loc = Loc.new( + file: @file, + begin_line: first_loc&.begin_line || 0, + begin_column: first_loc&.begin_column || 0, + end_line: last_loc&.end_line || 0, + end_column: last_loc&.end_column || 0, + ) + end - sig { returns(Sig) } - attr_reader :current + sig { params(node: T.nilable(YARP::Node)).returns(T::Boolean) } + def type_variable_definition?(node) + return false unless node.is_a?(YARP::CallNode) + return false unless node.block - sig { void } - def initialize - super - @current = T.let(Sig.new, Sig) + node.message == "type_member" || node.message == "type_template" + end end - class << self + class SigBuilder < Visitor extend T::Sig - sig { params(node: AST::Node).returns(Sig) } - def build(node) - v = SigBuilder.new - v.visit_all(node.children) - v.current - end - end + sig { returns(Sig) } + attr_accessor :current - sig { override.params(node: T.nilable(AST::Node)).void } - def visit(node) - return unless node + sig { params(content: String, file: String).void } + def initialize(content, file:) + super - case node.type - when :send - visit_send(node) + @current = T.let(Sig.new, Sig) end - end - sig { params(node: AST::Node).void } - def visit_send(node) - visit(node.children[0]) if node.children[0] - name = node.children[1] - case name - when :sig - arg = node.children[2] - @current.is_final = arg && arg.children[0] == :final - when :abstract - @current.is_abstract = true - when :override - @current.is_override = true - when :overridable - @current.is_overridable = true - when :checked - if node.children.length >= 3 - @current.checked = node.children[2].children[0] - end - when :type_parameters - node.children[2..-1].each do |child| - @current.type_params << child.children[0].to_s - end - when :params - if node.children.length >= 3 - node.children[2].children.each do |child| - name = child.children[0].children[0].to_s - type = parse_expr(child.children[1]) - @current << SigParam.new(name, type) + sig { override.params(node: YARP::CallNode).void } + def visit_call_node(node) + case node.message + when "sig" + args = node.arguments + if args.is_a?(YARP::ArgumentsNode) + args.arguments.each do |arg| + @current.is_final = node_string(arg) == ":final" + end end + when "abstract" + @current.is_abstract = true + when "checked" + args = node.arguments + if args.is_a?(YARP::ArgumentsNode) + arg = node_string(args.arguments.first) + @current.checked = arg&.delete_prefix(":")&.to_sym + end + when "override" + @current.is_override = true + when "overridable" + @current.is_overridable = true + when "params" + visit(node.arguments) + when "returns" + args = node.arguments + if args.is_a?(YARP::ArgumentsNode) + first = args.arguments.first + @current.return_type = node_string!(first) if first + end + when "type_parameters" + args = node.arguments + if args.is_a?(YARP::ArgumentsNode) + args.arguments.each do |arg| + @current.type_params << node_string!(arg).delete_prefix(":") + end + end + when "void" + @current.return_type = nil end - when :returns - if node.children.length >= 3 - @current.return_type = parse_expr(node.children[2]) - end - when :void - @current.return_type = nil - else - raise "#{node.location.line}: Unhandled #{name}" - end - end - end - class Loc - class << self - extend T::Sig + visit(node.receiver) + visit(node.block) + end - sig { params(file: String, ast_loc: T.any(::Parser::Source::Map, ::Parser::Source::Range)).returns(Loc) } - def from_ast_loc(file, ast_loc) - Loc.new( - file: file, - begin_line: ast_loc.line, - begin_column: ast_loc.column, - end_line: ast_loc.last_line, - end_column: ast_loc.last_column, + sig { override.params(node: YARP::AssocNode).void } + def visit_assoc_node(node) + @current.params << SigParam.new( + node_string!(node.key).delete_suffix(":"), + node_string!(T.must(node.value)), ) end end diff --git a/rbi.gemspec b/rbi.gemspec index 22a94a2e..94b03fea 100644 --- a/rbi.gemspec +++ b/rbi.gemspec @@ -24,8 +24,6 @@ Gem::Specification.new do |spec| "Rakefile", ] - spec.add_dependency("ast") - spec.add_dependency("parser", ">= 3.0.0") spec.add_dependency("sorbet-runtime", ">= 0.5.9204") - spec.add_dependency("unparser", ">= 0.5.6") + spec.add_dependency("yarp", ">= 0.10.0") end diff --git a/sorbet/rbi/gems/diff-lcs@1.5.0.rbi b/sorbet/rbi/gems/diff-lcs@1.5.0.rbi deleted file mode 100644 index a9a3d67e..00000000 --- a/sorbet/rbi/gems/diff-lcs@1.5.0.rbi +++ /dev/null @@ -1,1079 +0,0 @@ -# typed: true - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `diff-lcs` gem. -# Please instead update this file by running `bin/tapioca gem diff-lcs`. - -# source://diff-lcs//lib/diff/lcs.rb#3 -module Diff; end - -# source://diff-lcs//lib/diff/lcs.rb#51 -module Diff::LCS - # Returns the difference set between +self+ and +other+. See Diff::LCS#diff. - # - # source://diff-lcs//lib/diff/lcs.rb#75 - def diff(other, callbacks = T.unsafe(nil), &block); end - - # Returns an Array containing the longest common subsequence(s) between - # +self+ and +other+. See Diff::LCS#lcs. - # - # lcs = seq1.lcs(seq2) - # - # A note when using objects: Diff::LCS only works properly when each object - # can be used as a key in a Hash, which typically means that the objects must - # implement Object#eql? in a way that two identical values compare - # identically for key purposes. That is: - # - # O.new('a').eql?(O.new('a')) == true - # - # source://diff-lcs//lib/diff/lcs.rb#70 - def lcs(other, &block); end - - # Attempts to patch +self+ with the provided +patchset+. A new sequence based - # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts - # to autodiscover the direction of the patch. - # - # source://diff-lcs//lib/diff/lcs.rb#101 - def patch(patchset); end - - # Attempts to patch +self+ with the provided +patchset+. A new sequence based - # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Does no - # patch direction autodiscovery. - # - # source://diff-lcs//lib/diff/lcs.rb#109 - def patch!(patchset); end - - # Attempts to patch +self+ with the provided +patchset+, using #patch!. If - # the sequence this is used on supports #replace, the value of +self+ will be - # replaced. See Diff::LCS#patch. Does no patch direction autodiscovery. - # - # source://diff-lcs//lib/diff/lcs.rb#123 - def patch_me(patchset); end - - # Returns the balanced ("side-by-side") difference set between +self+ and - # +other+. See Diff::LCS#sdiff. - # - # source://diff-lcs//lib/diff/lcs.rb#81 - def sdiff(other, callbacks = T.unsafe(nil), &block); end - - # Traverses the discovered longest common subsequences between +self+ and - # +other+ using the alternate, balanced algorithm. See - # Diff::LCS#traverse_balanced. - # - # source://diff-lcs//lib/diff/lcs.rb#94 - def traverse_balanced(other, callbacks = T.unsafe(nil), &block); end - - # Traverses the discovered longest common subsequences between +self+ and - # +other+. See Diff::LCS#traverse_sequences. - # - # source://diff-lcs//lib/diff/lcs.rb#87 - def traverse_sequences(other, callbacks = T.unsafe(nil), &block); end - - # Attempts to patch +self+ with the provided +patchset+. A new sequence based - # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts - # to autodiscover the direction of the patch. - # - # source://diff-lcs//lib/diff/lcs.rb#101 - def unpatch(patchset); end - - # Attempts to unpatch +self+ with the provided +patchset+. A new sequence - # based on +self+ and the +patchset+ will be created. See Diff::LCS#unpatch. - # Does no patch direction autodiscovery. - # - # source://diff-lcs//lib/diff/lcs.rb#116 - def unpatch!(patchset); end - - # Attempts to unpatch +self+ with the provided +patchset+, using #unpatch!. - # If the sequence this is used on supports #replace, the value of +self+ will - # be replaced. See Diff::LCS#unpatch. Does no patch direction autodiscovery. - # - # source://diff-lcs//lib/diff/lcs.rb#134 - def unpatch_me(patchset); end - - class << self - # :yields seq1[i] for each matched: - # - # source://diff-lcs//lib/diff/lcs.rb#144 - def LCS(seq1, seq2, &block); end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#52 - def callbacks_for(callbacks); end - - # #diff computes the smallest set of additions and deletions necessary to - # turn the first sequence into the second, and returns a description of these - # changes. - # - # See Diff::LCS::DiffCallbacks for the default behaviour. An alternate - # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a - # Class argument is provided for +callbacks+, #diff will attempt to - # initialise it. If the +callbacks+ object (possibly initialised) responds to - # #finish, it will be called. - # - # source://diff-lcs//lib/diff/lcs.rb#168 - def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end - - # :yields seq1[i] for each matched: - # - # source://diff-lcs//lib/diff/lcs.rb#144 - def lcs(seq1, seq2, &block); end - - # Applies a +patchset+ to the sequence +src+ according to the +direction+ - # (:patch or :unpatch), producing a new sequence. - # - # If the +direction+ is not specified, Diff::LCS::patch will attempt to - # discover the direction of the +patchset+. - # - # A +patchset+ can be considered to apply forward (:patch) if the - # following expression is true: - # - # patch(s1, diff(s1, s2)) -> s2 - # - # A +patchset+ can be considered to apply backward (:unpatch) if the - # following expression is true: - # - # patch(s2, diff(s1, s2)) -> s1 - # - # If the +patchset+ contains no changes, the +src+ value will be returned as - # either src.dup or +src+. A +patchset+ can be deemed as having no - # changes if the following predicate returns true: - # - # patchset.empty? or - # patchset.flatten(1).all? { |change| change.unchanged? } - # - # === Patchsets - # - # A +patchset+ is always an enumerable sequence of changes, hunks of changes, - # or a mix of the two. A hunk of changes is an enumerable sequence of - # changes: - # - # [ # patchset - # # change - # [ # hunk - # # change - # ] - # ] - # - # The +patch+ method accepts patchsets that are enumerable sequences - # containing either Diff::LCS::Change objects (or a subclass) or the array - # representations of those objects. Prior to application, array - # representations of Diff::LCS::Change objects will be reified. - # - # source://diff-lcs//lib/diff/lcs.rb#624 - def patch(src, patchset, direction = T.unsafe(nil)); end - - # Given a set of patchset, convert the current version to the next version. - # Does no auto-discovery. - # - # source://diff-lcs//lib/diff/lcs.rb#734 - def patch!(src, patchset); end - - # #sdiff computes all necessary components to show two sequences and their - # minimized differences side by side, just like the Unix utility - # sdiff does: - # - # old < - - # same same - # before | after - # - > new - # - # See Diff::LCS::SDiffCallbacks for the default behaviour. An alternate - # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a - # Class argument is provided for +callbacks+, #diff will attempt to - # initialise it. If the +callbacks+ object (possibly initialised) responds to - # #finish, it will be called. - # - # Each element of a returned array is a Diff::LCS::ContextChange object, - # which can be implicitly converted to an array. - # - # Diff::LCS.sdiff(a, b).each do |action, (old_pos, old_element), (new_pos, new_element)| - # case action - # when '!' - # # replace - # when '-' - # # delete - # when '+' - # # insert - # end - # end - # - # source://diff-lcs//lib/diff/lcs.rb#200 - def sdiff(seq1, seq2, callbacks = T.unsafe(nil), &block); end - - # #traverse_balanced is an alternative to #traverse_sequences. It uses a - # different algorithm to iterate through the entries in the computed longest - # common subsequence. Instead of viewing the changes as insertions or - # deletions from one of the sequences, #traverse_balanced will report - # changes between the sequences. - # - # The arguments to #traverse_balanced are the two sequences to traverse and a - # callback object, like this: - # - # traverse_balanced(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new) - # - # #sdiff is implemented with #traverse_balanced. - # - # == Callback Methods - # - # Optional callback methods are emphasized. - # - # callbacks#match:: Called when +a+ and +b+ are pointing to - # common elements in +A+ and +B+. - # callbacks#discard_a:: Called when +a+ is pointing to an - # element not in +B+. - # callbacks#discard_b:: Called when +b+ is pointing to an - # element not in +A+. - # callbacks#change:: Called when +a+ and +b+ are pointing to - # the same relative position, but - # A[a] and B[b] are not - # the same; a change has - # occurred. - # - # #traverse_balanced might be a bit slower than #traverse_sequences, - # noticable only while processing huge amounts of data. - # - # == Algorithm - # - # a---+ - # v - # A = a b c e h j l m n p - # B = b c d e f j k l m r s t - # ^ - # b---+ - # - # === Matches - # - # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+ - # and +B+, the arrows will initially point to the first elements of their - # respective sequences. #traverse_sequences will advance the arrows through - # the sequences one element at a time, calling a method on the user-specified - # callback object before each advance. It will advance the arrows in such a - # way that if there are elements A[i] and B[j] which are - # both equal and part of the longest common subsequence, there will be some - # moment during the execution of #traverse_sequences when arrow +a+ is - # pointing to A[i] and arrow +b+ is pointing to B[j]. When - # this happens, #traverse_sequences will call callbacks#match and - # then it will advance both arrows. - # - # === Discards - # - # Otherwise, one of the arrows is pointing to an element of its sequence that - # is not part of the longest common subsequence. #traverse_sequences will - # advance that arrow and will call callbacks#discard_a or - # callbacks#discard_b, depending on which arrow it advanced. - # - # === Changes - # - # If both +a+ and +b+ point to elements that are not part of the longest - # common subsequence, then #traverse_sequences will try to call - # callbacks#change and advance both arrows. If - # callbacks#change is not implemented, then - # callbacks#discard_a and callbacks#discard_b will be - # called in turn. - # - # The methods for callbacks#match, callbacks#discard_a, - # callbacks#discard_b, and callbacks#change are invoked - # with an event comprising the action ("=", "+", "-", or "!", respectively), - # the indicies +i+ and +j+, and the elements A[i] and B[j]. - # Return values are discarded by #traverse_balanced. - # - # === Context - # - # Note that +i+ and +j+ may not be the same index position, even if +a+ and - # +b+ are considered to be pointing to matching or changed elements. - # - # source://diff-lcs//lib/diff/lcs.rb#475 - def traverse_balanced(seq1, seq2, callbacks = T.unsafe(nil)); end - - # #traverse_sequences is the most general facility provided by this module; - # #diff and #lcs are implemented as calls to it. - # - # The arguments to #traverse_sequences are the two sequences to traverse, and - # a callback object, like this: - # - # traverse_sequences(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new) - # - # == Callback Methods - # - # Optional callback methods are emphasized. - # - # callbacks#match:: Called when +a+ and +b+ are pointing to - # common elements in +A+ and +B+. - # callbacks#discard_a:: Called when +a+ is pointing to an - # element not in +B+. - # callbacks#discard_b:: Called when +b+ is pointing to an - # element not in +A+. - # callbacks#finished_a:: Called when +a+ has reached the end of - # sequence +A+. - # callbacks#finished_b:: Called when +b+ has reached the end of - # sequence +B+. - # - # == Algorithm - # - # a---+ - # v - # A = a b c e h j l m n p - # B = b c d e f j k l m r s t - # ^ - # b---+ - # - # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+ - # and +B+, the arrows will initially point to the first elements of their - # respective sequences. #traverse_sequences will advance the arrows through - # the sequences one element at a time, calling a method on the user-specified - # callback object before each advance. It will advance the arrows in such a - # way that if there are elements A[i] and B[j] which are - # both equal and part of the longest common subsequence, there will be some - # moment during the execution of #traverse_sequences when arrow +a+ is - # pointing to A[i] and arrow +b+ is pointing to B[j]. When - # this happens, #traverse_sequences will call callbacks#match and - # then it will advance both arrows. - # - # Otherwise, one of the arrows is pointing to an element of its sequence that - # is not part of the longest common subsequence. #traverse_sequences will - # advance that arrow and will call callbacks#discard_a or - # callbacks#discard_b, depending on which arrow it advanced. If both - # arrows point to elements that are not part of the longest common - # subsequence, then #traverse_sequences will advance arrow +a+ and call the - # appropriate callback, then it will advance arrow +b+ and call the appropriate - # callback. - # - # The methods for callbacks#match, callbacks#discard_a, and - # callbacks#discard_b are invoked with an event comprising the - # action ("=", "+", or "-", respectively), the indicies +i+ and +j+, and the - # elements A[i] and B[j]. Return values are discarded by - # #traverse_sequences. - # - # === End of Sequences - # - # If arrow +a+ reaches the end of its sequence before arrow +b+ does, - # #traverse_sequence will try to call callbacks#finished_a with the - # last index and element of +A+ (A[-1]) and the current index and - # element of +B+ (B[j]). If callbacks#finished_a does not - # exist, then callbacks#discard_b will be called on each element of - # +B+ until the end of the sequence is reached (the call will be done with - # A[-1] and B[j] for each element). - # - # If +b+ reaches the end of +B+ before +a+ reaches the end of +A+, - # callbacks#finished_b will be called with the current index and - # element of +A+ (A[i]) and the last index and element of +B+ - # (A[-1]). Again, if callbacks#finished_b does not exist on - # the callback object, then callbacks#discard_a will be called on - # each element of +A+ until the end of the sequence is reached (A[i] - # and B[-1]). - # - # There is a chance that one additional callbacks#discard_a or - # callbacks#discard_b will be called after the end of the sequence - # is reached, if +a+ has not yet reached the end of +A+ or +b+ has not yet - # reached the end of +B+. - # - # source://diff-lcs//lib/diff/lcs.rb#285 - def traverse_sequences(seq1, seq2, callbacks = T.unsafe(nil)); end - - # Given a set of patchset, convert the current version to the prior version. - # Does no auto-discovery. - # - # source://diff-lcs//lib/diff/lcs.rb#728 - def unpatch!(src, patchset); end - - private - - # source://diff-lcs//lib/diff/lcs/internals.rb#4 - def diff_traversal(method, seq1, seq2, callbacks, &block); end - end -end - -# An alias for DefaultCallbacks that is used in -# Diff::LCS#traverse_balanced. -# -# Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks) -# -# source://diff-lcs//lib/diff/lcs/callbacks.rb#50 -Diff::LCS::BalancedCallbacks = Diff::LCS::DefaultCallbacks - -# A block is an operation removing, adding, or changing a group of items. -# Basically, this is just a list of changes, where each change adds or -# deletes a single item. Used by bin/ldiff. -# -# source://diff-lcs//lib/diff/lcs/block.rb#6 -class Diff::LCS::Block - # @return [Block] a new instance of Block - # - # source://diff-lcs//lib/diff/lcs/block.rb#9 - def initialize(chunk); end - - # Returns the value of attribute changes. - # - # source://diff-lcs//lib/diff/lcs/block.rb#7 - def changes; end - - # source://diff-lcs//lib/diff/lcs/block.rb#21 - def diff_size; end - - # Returns the value of attribute insert. - # - # source://diff-lcs//lib/diff/lcs/block.rb#7 - def insert; end - - # source://diff-lcs//lib/diff/lcs/block.rb#25 - def op; end - - # Returns the value of attribute remove. - # - # source://diff-lcs//lib/diff/lcs/block.rb#7 - def remove; end -end - -# Represents a simplistic (non-contextual) change. Represents the removal or -# addition of an element from either the old or the new sequenced -# enumerable. -# -# source://diff-lcs//lib/diff/lcs/change.rb#6 -class Diff::LCS::Change - include ::Comparable - - # @return [Change] a new instance of Change - # - # source://diff-lcs//lib/diff/lcs/change.rb#27 - def initialize(*args); end - - # source://diff-lcs//lib/diff/lcs/change.rb#65 - def <=>(other); end - - # source://diff-lcs//lib/diff/lcs/change.rb#58 - def ==(other); end - - # Returns the action this Change represents. - # - # source://diff-lcs//lib/diff/lcs/change.rb#20 - def action; end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/change.rb#72 - def adding?; end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/change.rb#84 - def changed?; end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/change.rb#76 - def deleting?; end - - # Returns the sequence element of the Change. - # - # source://diff-lcs//lib/diff/lcs/change.rb#25 - def element; end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/change.rb#88 - def finished_a?; end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/change.rb#92 - def finished_b?; end - - # source://diff-lcs//lib/diff/lcs/change.rb#34 - def inspect(*_args); end - - # Returns the position of the Change. - # - # source://diff-lcs//lib/diff/lcs/change.rb#23 - def position; end - - # source://diff-lcs//lib/diff/lcs/change.rb#38 - def to_a; end - - # source://diff-lcs//lib/diff/lcs/change.rb#38 - def to_ary; end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/change.rb#80 - def unchanged?; end - - class << self - # source://diff-lcs//lib/diff/lcs/change.rb#44 - def from_a(arr); end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/change.rb#15 - def valid_action?(action); end - end -end - -# source://diff-lcs//lib/diff/lcs/change.rb#7 -Diff::LCS::Change::IntClass = Integer - -# The only actions valid for changes are '+' (add), '-' (delete), '=' -# (no change), '!' (changed), '<' (tail changes from first sequence), or -# '>' (tail changes from second sequence). The last two ('<>') are only -# found with Diff::LCS::diff and Diff::LCS::sdiff. -# -# source://diff-lcs//lib/diff/lcs/change.rb#13 -Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array) - -# Represents a contextual change. Contains the position and values of the -# elements in the old and the new sequenced enumerables as well as the action -# taken. -# -# source://diff-lcs//lib/diff/lcs/change.rb#101 -class Diff::LCS::ContextChange < ::Diff::LCS::Change - # @return [ContextChange] a new instance of ContextChange - # - # source://diff-lcs//lib/diff/lcs/change.rb#114 - def initialize(*args); end - - # source://diff-lcs//lib/diff/lcs/change.rb#166 - def <=>(other); end - - # source://diff-lcs//lib/diff/lcs/change.rb#157 - def ==(other); end - - # Returns the new element being changed. - # - # source://diff-lcs//lib/diff/lcs/change.rb#112 - def new_element; end - - # Returns the new position being changed. - # - # source://diff-lcs//lib/diff/lcs/change.rb#108 - def new_position; end - - # Returns the old element being changed. - # - # source://diff-lcs//lib/diff/lcs/change.rb#110 - def old_element; end - - # Returns the old position being changed. - # - # source://diff-lcs//lib/diff/lcs/change.rb#106 - def old_position; end - - # source://diff-lcs//lib/diff/lcs/change.rb#122 - def to_a; end - - # source://diff-lcs//lib/diff/lcs/change.rb#122 - def to_ary; end - - class << self - # source://diff-lcs//lib/diff/lcs/change.rb#132 - def from_a(arr); end - - # Simplifies a context change for use in some diff callbacks. '<' actions - # are converted to '-' and '>' actions are converted to '+'. - # - # source://diff-lcs//lib/diff/lcs/change.rb#138 - def simplify(event); end - end -end - -# This will produce a compound array of contextual diff change objects. Each -# element in the #diffs array is a "hunk" array, where each element in each -# "hunk" array is a single change. Each change is a Diff::LCS::ContextChange -# that contains both the old index and new index values for the change. The -# "hunk" provides the full context for the changes. Both old and new objects -# will be presented for changed objects. +nil+ will be substituted for a -# discarded object. -# -# seq1 = %w(a b c e h j l m n p) -# seq2 = %w(b c d e f j k l m r s t) -# -# diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks) -# # This example shows a simplified array format. -# # [ [ [ '-', [ 0, 'a' ], [ 0, nil ] ] ], # 1 -# # [ [ '+', [ 3, nil ], [ 2, 'd' ] ] ], # 2 -# # [ [ '-', [ 4, 'h' ], [ 4, nil ] ], # 3 -# # [ '+', [ 5, nil ], [ 4, 'f' ] ] ], -# # [ [ '+', [ 6, nil ], [ 6, 'k' ] ] ], # 4 -# # [ [ '-', [ 8, 'n' ], [ 9, nil ] ], # 5 -# # [ '+', [ 9, nil ], [ 9, 'r' ] ], -# # [ '-', [ 9, 'p' ], [ 10, nil ] ], -# # [ '+', [ 10, nil ], [ 10, 's' ] ], -# # [ '+', [ 10, nil ], [ 11, 't' ] ] ] ] -# -# The five hunks shown are comprised of individual changes; if there is a -# related set of changes, they are still shown individually. -# -# This callback can also be used with Diff::LCS#sdiff, which will produce -# results like: -# -# diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks) -# # This example shows a simplified array format. -# # [ [ [ "-", [ 0, "a" ], [ 0, nil ] ] ], # 1 -# # [ [ "+", [ 3, nil ], [ 2, "d" ] ] ], # 2 -# # [ [ "!", [ 4, "h" ], [ 4, "f" ] ] ], # 3 -# # [ [ "+", [ 6, nil ], [ 6, "k" ] ] ], # 4 -# # [ [ "!", [ 8, "n" ], [ 9, "r" ] ], # 5 -# # [ "!", [ 9, "p" ], [ 10, "s" ] ], -# # [ "+", [ 10, nil ], [ 11, "t" ] ] ] ] -# -# The five hunks are still present, but are significantly shorter in total -# presentation, because changed items are shown as changes ("!") instead of -# potentially "mismatched" pairs of additions and deletions. -# -# The result of this operation is similar to that of -# Diff::LCS::SDiffCallbacks. They may be compared as: -# -# s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" } -# c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1) -# -# s == c # -> true -# -# === Use -# -# This callback object must be initialised and can be used by the -# Diff::LCS#diff or Diff::LCS#sdiff methods. -# -# cbo = Diff::LCS::ContextDiffCallbacks.new -# Diff::LCS.LCS(seq1, seq2, cbo) -# cbo.finish -# -# Note that the call to #finish is absolutely necessary, or the last set of -# changes will not be visible. Alternatively, can be used as: -# -# cbo = Diff::LCS::ContextDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } -# -# The necessary #finish call will be made. -# -# === Simplified Array Format -# -# The simplified array format used in the example above can be obtained -# with: -# -# require 'pp' -# pp diffs.map { |e| e.map { |f| f.to_a } } -# -# source://diff-lcs//lib/diff/lcs/callbacks.rb#223 -class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks - # source://diff-lcs//lib/diff/lcs/callbacks.rb#232 - def change(event); end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#224 - def discard_a(event); end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#228 - def discard_b(event); end -end - -# This callback object implements the default set of callback events, -# which only returns the event itself. Note that #finished_a and -# #finished_b are not implemented -- I haven't yet figured out where they -# would be useful. -# -# Note that this is intended to be called as is, e.g., -# -# Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks) -# -# source://diff-lcs//lib/diff/lcs/callbacks.rb#14 -class Diff::LCS::DefaultCallbacks - class << self - # Called when both the old and new values have changed. - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#32 - def change(event); end - - # Called when the old value is discarded in favour of the new value. - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#22 - def discard_a(event); end - - # Called when the new value is discarded in favour of the old value. - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#27 - def discard_b(event); end - - # Called when two items match. - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#17 - def match(event); end - end -end - -# This will produce a compound array of simple diff change objects. Each -# element in the #diffs array is a +hunk+ or +hunk+ array, where each -# element in each +hunk+ array is a single Change object representing the -# addition or removal of a single element from one of the two tested -# sequences. The +hunk+ provides the full context for the changes. -# -# diffs = Diff::LCS.diff(seq1, seq2) -# # This example shows a simplified array format. -# # [ [ [ '-', 0, 'a' ] ], # 1 -# # [ [ '+', 2, 'd' ] ], # 2 -# # [ [ '-', 4, 'h' ], # 3 -# # [ '+', 4, 'f' ] ], -# # [ [ '+', 6, 'k' ] ], # 4 -# # [ [ '-', 8, 'n' ], # 5 -# # [ '-', 9, 'p' ], -# # [ '+', 9, 'r' ], -# # [ '+', 10, 's' ], -# # [ '+', 11, 't' ] ] ] -# -# There are five hunks here. The first hunk says that the +a+ at position 0 -# of the first sequence should be deleted ('-'). The second hunk -# says that the +d+ at position 2 of the second sequence should be inserted -# ('+'). The third hunk says that the +h+ at position 4 of the -# first sequence should be removed and replaced with the +f+ from position 4 -# of the second sequence. The other two hunks are described similarly. -# -# === Use -# -# This callback object must be initialised and is used by the Diff::LCS#diff -# method. -# -# cbo = Diff::LCS::DiffCallbacks.new -# Diff::LCS.LCS(seq1, seq2, cbo) -# cbo.finish -# -# Note that the call to #finish is absolutely necessary, or the last set of -# changes will not be visible. Alternatively, can be used as: -# -# cbo = Diff::LCS::DiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } -# -# The necessary #finish call will be made. -# -# === Simplified Array Format -# -# The simplified array format used in the example above can be obtained -# with: -# -# require 'pp' -# pp diffs.map { |e| e.map { |f| f.to_a } } -# -# source://diff-lcs//lib/diff/lcs/callbacks.rb#106 -class Diff::LCS::DiffCallbacks - # :yields self: - # - # @return [DiffCallbacks] a new instance of DiffCallbacks - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#110 - def initialize; end - - # Returns the difference set collected during the diff process. - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#108 - def diffs; end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#133 - def discard_a(event); end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#137 - def discard_b(event); end - - # Finalizes the diff process. If an unprocessed hunk still exists, then it - # is appended to the diff list. - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#125 - def finish; end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#129 - def match(_event); end - - private - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#141 - def finish_hunk; end -end - -# A Hunk is a group of Blocks which overlap because of the context surrounding -# each block. (So if we're not using context, every hunk will contain one -# block.) Used in the diff program (bin/ldiff). -# -# source://diff-lcs//lib/diff/lcs/hunk.rb#8 -class Diff::LCS::Hunk - # Create a hunk using references to both the old and new data, as well as the - # piece of data. - # - # @return [Hunk] a new instance of Hunk - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#16 - def initialize(data_old, data_new, piece, flag_context, file_length_difference); end - - # Returns the value of attribute blocks. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#63 - def blocks; end - - # Returns a diff string based on a format. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#116 - def diff(format, last = T.unsafe(nil)); end - - # Returns the value of attribute end_new. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#65 - def end_new; end - - # Returns the value of attribute end_old. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#65 - def end_old; end - - # Returns the value of attribute file_length_difference. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#66 - def file_length_difference; end - - # Change the "start" and "end" fields to note that context should be added - # to this hunk. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#70 - def flag_context; end - - # source://diff-lcs//lib/diff/lcs/hunk.rb#72 - def flag_context=(context); end - - # Merges this hunk and the provided hunk together if they overlap. Returns - # a truthy value so that if there is no overlap, you can know the merge - # was skipped. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#98 - def merge(hunk); end - - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#326 - def missing_last_newline?(data); end - - # Determines whether there is an overlap between this hunk and the - # provided hunk. This will be true if the difference between the two hunks - # start or end positions is within one position of each other. - # - # @return [Boolean] - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#110 - def overlaps?(hunk); end - - # Returns the value of attribute start_new. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#64 - def start_new; end - - # Returns the value of attribute start_old. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#64 - def start_old; end - - # Merges this hunk and the provided hunk together if they overlap. Returns - # a truthy value so that if there is no overlap, you can know the merge - # was skipped. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#98 - def unshift(hunk); end - - private - - # source://diff-lcs//lib/diff/lcs/hunk.rb#213 - def context_diff(last = T.unsafe(nil)); end - - # Generate a range of item numbers to print. Only print 1 number if the - # range has only one item in it. Otherwise, it's 'start,end' - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#293 - def context_range(mode, op, last = T.unsafe(nil)); end - - # source://diff-lcs//lib/diff/lcs/hunk.rb#271 - def ed_diff(format, _last = T.unsafe(nil)); end - - # source://diff-lcs//lib/diff/lcs/hunk.rb#339 - def encode(literal, target_encoding = T.unsafe(nil)); end - - # source://diff-lcs//lib/diff/lcs/hunk.rb#343 - def encode_as(string, *args); end - - # Note that an old diff can't have any context. Therefore, we know that - # there's only one block in the hunk. - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#135 - def old_diff(_last = T.unsafe(nil)); end - - # source://diff-lcs//lib/diff/lcs/hunk.rb#160 - def unified_diff(last = T.unsafe(nil)); end - - # Generate a range of item numbers to print for unified diff. Print number - # where block starts, followed by number of lines in the block - # (don't print number of lines if it's 1) - # - # source://diff-lcs//lib/diff/lcs/hunk.rb#311 - def unified_range(mode, last); end -end - -# source://diff-lcs//lib/diff/lcs/hunk.rb#10 -Diff::LCS::Hunk::ED_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash) - -# source://diff-lcs//lib/diff/lcs/hunk.rb#9 -Diff::LCS::Hunk::OLD_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash) - -# source://diff-lcs//lib/diff/lcs/internals.rb#29 -module Diff::LCS::Internals - class << self - # This method will analyze the provided patchset to provide a single-pass - # normalization (conversion of the array form of Diff::LCS::Change objects to - # the object form of same) and detection of whether the patchset represents - # changes to be made. - # - # source://diff-lcs//lib/diff/lcs/internals.rb#102 - def analyze_patchset(patchset, depth = T.unsafe(nil)); end - - # Examine the patchset and the source to see in which direction the - # patch should be applied. - # - # WARNING: By default, this examines the whole patch, so this could take - # some time. This also works better with Diff::LCS::ContextChange or - # Diff::LCS::Change as its source, as an array will cause the creation - # of one of the above. - # - # source://diff-lcs//lib/diff/lcs/internals.rb#147 - def intuit_diff_direction(src, patchset, limit = T.unsafe(nil)); end - - # Compute the longest common subsequence between the sequenced - # Enumerables +a+ and +b+. The result is an array whose contents is such - # that - # - # result = Diff::LCS::Internals.lcs(a, b) - # result.each_with_index do |e, i| - # assert_equal(a[i], b[e]) unless e.nil? - # end - # - # source://diff-lcs//lib/diff/lcs/internals.rb#41 - def lcs(a, b); end - - private - - # If +vector+ maps the matching elements of another collection onto this - # Enumerable, compute the inverse of +vector+ that maps this Enumerable - # onto the collection. (Currently unused.) - # - # source://diff-lcs//lib/diff/lcs/internals.rb#286 - def inverse_vector(a, vector); end - - # Returns a hash mapping each element of an Enumerable to the set of - # positions it occupies in the Enumerable, optionally restricted to the - # elements specified in the range of indexes specified by +interval+. - # - # source://diff-lcs//lib/diff/lcs/internals.rb#298 - def position_hash(enum, interval); end - - # Find the place at which +value+ would normally be inserted into the - # Enumerable. If that place is already occupied by +value+, do nothing - # and return +nil+. If the place does not exist (i.e., it is off the end - # of the Enumerable), add it to the end. Otherwise, replace the element - # at that point with +value+. It is assumed that the Enumerable's values - # are numeric. - # - # This operation preserves the sort order. - # - # source://diff-lcs//lib/diff/lcs/internals.rb#252 - def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end - end -end - -# This will produce a simple array of diff change objects. Each element in -# the #diffs array is a single ContextChange. In the set of #diffs provided -# by SDiffCallbacks, both old and new objects will be presented for both -# changed and unchanged objects. +nil+ will be substituted -# for a discarded object. -# -# The diffset produced by this callback, when provided to Diff::LCS#sdiff, -# will compute and display the necessary components to show two sequences -# and their minimized differences side by side, just like the Unix utility -# +sdiff+. -# -# same same -# before | after -# old < - -# - > new -# -# seq1 = %w(a b c e h j l m n p) -# seq2 = %w(b c d e f j k l m r s t) -# -# diffs = Diff::LCS.sdiff(seq1, seq2) -# # This example shows a simplified array format. -# # [ [ "-", [ 0, "a"], [ 0, nil ] ], -# # [ "=", [ 1, "b"], [ 0, "b" ] ], -# # [ "=", [ 2, "c"], [ 1, "c" ] ], -# # [ "+", [ 3, nil], [ 2, "d" ] ], -# # [ "=", [ 3, "e"], [ 3, "e" ] ], -# # [ "!", [ 4, "h"], [ 4, "f" ] ], -# # [ "=", [ 5, "j"], [ 5, "j" ] ], -# # [ "+", [ 6, nil], [ 6, "k" ] ], -# # [ "=", [ 6, "l"], [ 7, "l" ] ], -# # [ "=", [ 7, "m"], [ 8, "m" ] ], -# # [ "!", [ 8, "n"], [ 9, "r" ] ], -# # [ "!", [ 9, "p"], [ 10, "s" ] ], -# # [ "+", [ 10, nil], [ 11, "t" ] ] ] -# -# The result of this operation is similar to that of -# Diff::LCS::ContextDiffCallbacks. They may be compared as: -# -# s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" } -# c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1) -# -# s == c # -> true -# -# === Use -# -# This callback object must be initialised and is used by the Diff::LCS#sdiff -# method. -# -# cbo = Diff::LCS::SDiffCallbacks.new -# Diff::LCS.LCS(seq1, seq2, cbo) -# -# As with the other initialisable callback objects, -# Diff::LCS::SDiffCallbacks can be initialised with a block. As there is no -# "fininishing" to be done, this has no effect on the state of the object. -# -# cbo = Diff::LCS::SDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } -# -# === Simplified Array Format -# -# The simplified array format used in the example above can be obtained -# with: -# -# require 'pp' -# pp diffs.map { |e| e.to_a } -# -# source://diff-lcs//lib/diff/lcs/callbacks.rb#301 -class Diff::LCS::SDiffCallbacks - # :yields self: - # - # @return [SDiffCallbacks] a new instance of SDiffCallbacks - # @yield [_self] - # @yieldparam _self [Diff::LCS::SDiffCallbacks] the object that the method was called on - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#305 - def initialize; end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#322 - def change(event); end - - # Returns the difference set collected during the diff process. - # - # source://diff-lcs//lib/diff/lcs/callbacks.rb#303 - def diffs; end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#314 - def discard_a(event); end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#318 - def discard_b(event); end - - # source://diff-lcs//lib/diff/lcs/callbacks.rb#310 - def match(event); end -end - -# An alias for DefaultCallbacks that is used in -# Diff::LCS#traverse_sequences. -# -# Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks) -# -# source://diff-lcs//lib/diff/lcs/callbacks.rb#44 -Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks - -# source://diff-lcs//lib/diff/lcs.rb#52 -Diff::LCS::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/json@2.6.3.rbi b/sorbet/rbi/gems/json@2.6.3.rbi index b379bc4b..259116aa 100644 --- a/sorbet/rbi/gems/json@2.6.3.rbi +++ b/sorbet/rbi/gems/json@2.6.3.rbi @@ -5,8 +5,6 @@ # Please instead update this file by running `bin/tapioca gem json`. # Extends any Class to include _json_creatable?_ method. -# -# source://json//lib/json/common.rb#695 class Class < ::Module # Returns true if this class can be used to create an instance # from a serialised JSON string. The class has to implement a class @@ -15,7 +13,7 @@ class Class < ::Module # # @return [Boolean] # - # source://json//lib/json/common.rb#700 + # source://json//json/common.rb#700 def json_creatable?; end end @@ -588,8 +586,6 @@ end # Parsed JSON: # Without custom addition: "#" (String) # With custom addition: # (Foo) -# -# source://json//lib/json/version.rb#2 module JSON private @@ -621,7 +617,7 @@ module JSON # Output: # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} # - # source://json//lib/json/common.rb#631 + # source://json//json/common.rb#631 def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end # :call-seq: @@ -638,13 +634,13 @@ module JSON # # Raises SystemStackError (stack level too deep): # JSON.fast_generate(a) # - # source://json//lib/json/common.rb#335 + # source://json//json/common.rb#335 def fast_generate(obj, opts = T.unsafe(nil)); end # :stopdoc: # I want to deprecate these later, so I'll first be silent about them, and later delete them. # - # source://json//lib/json/common.rb#335 + # source://json//json/common.rb#335 def fast_unparse(obj, opts = T.unsafe(nil)); end # :call-seq: @@ -683,7 +679,7 @@ module JSON # # Raises JSON::NestingError (nesting of 100 is too deep): # JSON.generate(a) # - # source://json//lib/json/common.rb#296 + # source://json//json/common.rb#296 def generate(obj, opts = T.unsafe(nil)); end # :call-seq: @@ -814,7 +810,7 @@ module JSON # #"Admin", "password"=>"0wn3d"}>} # - # source://json//lib/json/common.rb#557 + # source://json//json/common.rb#557 def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end # :call-seq: @@ -825,7 +821,7 @@ module JSON # # See method #parse. # - # source://json//lib/json/common.rb#245 + # source://json//json/common.rb#245 def load_file(filespec, opts = T.unsafe(nil)); end # :call-seq: @@ -836,7 +832,7 @@ module JSON # # See method #parse! # - # source://json//lib/json/common.rb#256 + # source://json//json/common.rb#256 def load_file!(filespec, opts = T.unsafe(nil)); end # :call-seq: @@ -887,7 +883,7 @@ module JSON # # Raises JSON::ParserError (783: unexpected token at ''): # JSON.parse('') # - # source://json//lib/json/common.rb#215 + # source://json//json/common.rb#215 def parse(source, opts = T.unsafe(nil)); end # :call-seq: @@ -902,7 +898,7 @@ module JSON # which disables checking for nesting depth. # - Option +allow_nan+, if not provided, defaults to +true+. # - # source://json//lib/json/common.rb#230 + # source://json//json/common.rb#230 def parse!(source, opts = T.unsafe(nil)); end # :call-seq: @@ -935,28 +931,28 @@ module JSON # } # } # - # source://json//lib/json/common.rb#390 + # source://json//json/common.rb#390 def pretty_generate(obj, opts = T.unsafe(nil)); end # :stopdoc: # I want to deprecate these later, so I'll first be silent about them, and later delete them. # - # source://json//lib/json/common.rb#390 + # source://json//json/common.rb#390 def pretty_unparse(obj, opts = T.unsafe(nil)); end # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_ # - # source://json//lib/json/common.rb#575 + # source://json//json/common.rb#575 def recurse_proc(result, &proc); end - # source://json//lib/json/common.rb#557 + # source://json//json/common.rb#557 def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end # :stopdoc: # I want to deprecate these later, so I'll first be silent about them, and # later delete them. # - # source://json//lib/json/common.rb#296 + # source://json//json/common.rb#296 def unparse(obj, opts = T.unsafe(nil)); end class << self @@ -972,26 +968,26 @@ module JSON # ruby = [0, 1, nil] # JSON[ruby] # => '[0,1,null]' # - # source://json//lib/json/common.rb#18 + # source://json//json/common.rb#18 def [](object, opts = T.unsafe(nil)); end - # source://json//lib/json/common.rb#81 + # source://json//json/common.rb#81 def create_fast_state; end # Returns the current create identifier. # See also JSON.create_id=. # - # source://json//lib/json/common.rb#126 + # source://json//json/common.rb#126 def create_id; end # Sets create identifier, which is used to decide if the _json_create_ # hook of a class should be called; initial value is +json_class+: # JSON.create_id # => 'json_class' # - # source://json//lib/json/common.rb#120 + # source://json//json/common.rb#120 def create_id=(new_value); end - # source://json//lib/json/common.rb#91 + # source://json//json/common.rb#91 def create_pretty_state; end # Return the constant located at _path_. The format of _path_ has to be @@ -999,7 +995,7 @@ module JSON # level (absolute namespace path?). If there doesn't exist a constant at # the given path, an ArgumentError is raised. # - # source://json//lib/json/common.rb#42 + # source://json//json/common.rb#42 def deep_const_get(path); end # :call-seq: @@ -1030,7 +1026,7 @@ module JSON # Output: # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} # - # source://json//lib/json/common.rb#631 + # source://json//json/common.rb#631 def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end # Sets or returns the default options for the JSON.dump method. @@ -1038,7 +1034,7 @@ module JSON # opts = JSON.dump_default_options # opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false} # - # source://json//lib/json/common.rb#596 + # source://json//json/common.rb#596 def dump_default_options; end # Sets or returns the default options for the JSON.dump method. @@ -1046,7 +1042,7 @@ module JSON # opts = JSON.dump_default_options # opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false} # - # source://json//lib/json/common.rb#596 + # source://json//json/common.rb#596 def dump_default_options=(_arg0); end # :call-seq: @@ -1063,13 +1059,13 @@ module JSON # # Raises SystemStackError (stack level too deep): # JSON.fast_generate(a) # - # source://json//lib/json/common.rb#335 + # source://json//json/common.rb#335 def fast_generate(obj, opts = T.unsafe(nil)); end # :stopdoc: # I want to deprecate these later, so I'll first be silent about them, and later delete them. # - # source://json//lib/json/common.rb#335 + # source://json//json/common.rb#335 def fast_unparse(obj, opts = T.unsafe(nil)); end # :call-seq: @@ -1108,24 +1104,24 @@ module JSON # # Raises JSON::NestingError (nesting of 100 is too deep): # JSON.generate(a) # - # source://json//lib/json/common.rb#296 + # source://json//json/common.rb#296 def generate(obj, opts = T.unsafe(nil)); end # Returns the JSON generator module that is used by JSON. This is # either JSON::Ext::Generator or JSON::Pure::Generator: # JSON.generator # => JSON::Ext::Generator # - # source://json//lib/json/common.rb#103 + # source://json//json/common.rb#103 def generator; end # Set the module _generator_ to be used by JSON. # - # source://json//lib/json/common.rb#58 + # source://json//json/common.rb#58 def generator=(generator); end # Encodes string using String.encode. # - # source://json//lib/json/common.rb#653 + # source://json//json/common.rb#653 def iconv(to, from, string); end # :call-seq: @@ -1256,7 +1252,7 @@ module JSON # #"Admin", "password"=>"0wn3d"}>} # - # source://json//lib/json/common.rb#557 + # source://json//json/common.rb#557 def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end # Sets or returns default options for the JSON.load method. @@ -1264,7 +1260,7 @@ module JSON # opts = JSON.load_default_options # opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true} # - # source://json//lib/json/common.rb#420 + # source://json//json/common.rb#420 def load_default_options; end # Sets or returns default options for the JSON.load method. @@ -1272,7 +1268,7 @@ module JSON # opts = JSON.load_default_options # opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true} # - # source://json//lib/json/common.rb#420 + # source://json//json/common.rb#420 def load_default_options=(_arg0); end # :call-seq: @@ -1283,7 +1279,7 @@ module JSON # # See method #parse. # - # source://json//lib/json/common.rb#245 + # source://json//json/common.rb#245 def load_file(filespec, opts = T.unsafe(nil)); end # :call-seq: @@ -1294,7 +1290,7 @@ module JSON # # See method #parse! # - # source://json//lib/json/common.rb#256 + # source://json//json/common.rb#256 def load_file!(filespec, opts = T.unsafe(nil)); end # :call-seq: @@ -1345,7 +1341,7 @@ module JSON # # Raises JSON::ParserError (783: unexpected token at ''): # JSON.parse('') # - # source://json//lib/json/common.rb#215 + # source://json//json/common.rb#215 def parse(source, opts = T.unsafe(nil)); end # :call-seq: @@ -1360,19 +1356,19 @@ module JSON # which disables checking for nesting depth. # - Option +allow_nan+, if not provided, defaults to +true+. # - # source://json//lib/json/common.rb#230 + # source://json//json/common.rb#230 def parse!(source, opts = T.unsafe(nil)); end # Returns the JSON parser class that is used by JSON. This is either # JSON::Ext::Parser or JSON::Pure::Parser: # JSON.parser # => JSON::Ext::Parser # - # source://json//lib/json/common.rb#29 + # source://json//json/common.rb#29 def parser; end # Set the JSON parser class _parser_ to be used by JSON. # - # source://json//lib/json/common.rb#32 + # source://json//json/common.rb#32 def parser=(parser); end # :call-seq: @@ -1405,115 +1401,111 @@ module JSON # } # } # - # source://json//lib/json/common.rb#390 + # source://json//json/common.rb#390 def pretty_generate(obj, opts = T.unsafe(nil)); end # :stopdoc: # I want to deprecate these later, so I'll first be silent about them, and later delete them. # - # source://json//lib/json/common.rb#390 + # source://json//json/common.rb#390 def pretty_unparse(obj, opts = T.unsafe(nil)); end # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_ # - # source://json//lib/json/common.rb#575 + # source://json//json/common.rb#575 def recurse_proc(result, &proc); end - # source://json//lib/json/common.rb#557 + # source://json//json/common.rb#557 def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end # Sets or Returns the JSON generator state class that is used by JSON. This is # either JSON::Ext::Generator::State or JSON::Pure::Generator::State: # JSON.state # => JSON::Ext::Generator::State # - # source://json//lib/json/common.rb#108 + # source://json//json/common.rb#108 def state; end # Sets or Returns the JSON generator state class that is used by JSON. This is # either JSON::Ext::Generator::State or JSON::Pure::Generator::State: # JSON.state # => JSON::Ext::Generator::State # - # source://json//lib/json/common.rb#108 + # source://json//json/common.rb#108 def state=(_arg0); end # :stopdoc: # I want to deprecate these later, so I'll first be silent about them, and # later delete them. # - # source://json//lib/json/common.rb#296 + # source://json//json/common.rb#296 def unparse(obj, opts = T.unsafe(nil)); end end end -# source://json//lib/json/common.rb#114 +# source://json//json/common.rb#114 JSON::CREATE_ID_TLS_KEY = T.let(T.unsafe(nil), String) -# source://json//lib/json/common.rb#111 +# source://json//json/common.rb#111 JSON::DEFAULT_CREATE_ID = T.let(T.unsafe(nil), String) -# source://json//lib/json/generic_object.rb#5 class JSON::GenericObject < ::OpenStruct - # source://json//lib/json/generic_object.rb#63 + # source://json//json/generic_object.rb#63 def as_json(*_arg0); end - # source://json//lib/json/generic_object.rb#47 + # source://json//json/generic_object.rb#47 def to_hash; end - # source://json//lib/json/generic_object.rb#67 + # source://json//json/generic_object.rb#67 def to_json(*a); end - # source://json//lib/json/generic_object.rb#59 + # source://json//json/generic_object.rb#59 def |(other); end class << self - # source://json//lib/json/generic_object.rb#41 + # source://json//json/generic_object.rb#41 def dump(obj, *args); end - # source://json//lib/json/generic_object.rb#21 + # source://json//json/generic_object.rb#21 def from_hash(object); end # Sets the attribute json_creatable # # @param value the value to set the attribute json_creatable to. # - # source://json//lib/json/generic_object.rb#13 + # source://json//json/generic_object.rb#13 def json_creatable=(_arg0); end # @return [Boolean] # - # source://json//lib/json/generic_object.rb#9 + # source://json//json/generic_object.rb#9 def json_creatable?; end - # source://json//lib/json/generic_object.rb#15 + # source://json//json/generic_object.rb#15 def json_create(data); end - # source://json//lib/json/generic_object.rb#36 + # source://json//json/generic_object.rb#36 def load(source, proc = T.unsafe(nil), opts = T.unsafe(nil)); end end end # The base exception for JSON errors. -# -# source://json//lib/json/common.rb#137 class JSON::JSONError < ::StandardError class << self - # source://json//lib/json/common.rb#138 + # source://json//json/common.rb#138 def wrap(exception); end end end -# source://json//lib/json/common.rb#35 +# source://json//json/common.rb#35 JSON::Parser = JSON::Ext::Parser -# source://json//lib/json/common.rb#73 +# source://json//json/common.rb#73 JSON::State = JSON::Ext::Generator::State # For backwards compatibility # -# source://json//lib/json/common.rb#159 +# source://json//json/common.rb#159 JSON::UnparserError = JSON::GeneratorError -# source://json//lib/json/common.rb#658 module Kernel private @@ -1524,18 +1516,18 @@ module Kernel # The _opts_ argument is passed through to generate/parse respectively. See # generate and parse for their documentation. # - # source://json//lib/json/common.rb#685 + # source://json//json/common.rb#685 def JSON(object, *args); end # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in # one line. # - # source://json//lib/json/common.rb#663 + # source://json//json/common.rb#663 def j(*objs); end # Outputs _objs_ to STDOUT as JSON strings in a pretty format, with # indentation and over many lines. # - # source://json//lib/json/common.rb#672 + # source://json//json/common.rb#672 def jj(*objs); end end diff --git a/sorbet/rbi/gems/language_server-protocol@3.17.0.3.rbi b/sorbet/rbi/gems/language_server-protocol@3.17.0.3.rbi new file mode 100644 index 00000000..f6b1d8ed --- /dev/null +++ b/sorbet/rbi/gems/language_server-protocol@3.17.0.3.rbi @@ -0,0 +1,14237 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `language_server-protocol` gem. +# Please instead update this file by running `bin/tapioca gem language_server-protocol`. + +# source://language_server-protocol//lib/language_server/protocol/version.rb#1 +module LanguageServer; end + +# source://language_server-protocol//lib/language_server/protocol/version.rb#2 +module LanguageServer::Protocol; end + +# source://language_server-protocol//lib/language_server/protocol/constant.rb#3 +module LanguageServer::Protocol::Constant; end + +# The kind of a code action. +# +# Kinds are a hierarchical list of identifiers separated by `.`, +# e.g. `"refactor.extract.function"`. +# +# The set of kinds is open and client needs to announce the kinds it supports +# to the server during initialization. +# A set of predefined code action kinds. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#14 +module LanguageServer::Protocol::Constant::CodeActionKind; end + +# Empty kind. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#18 +LanguageServer::Protocol::Constant::CodeActionKind::EMPTY = T.let(T.unsafe(nil), String) + +# Base kind for quickfix actions: 'quickfix'. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#22 +LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX = T.let(T.unsafe(nil), String) + +# Base kind for refactoring actions: 'refactor'. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#26 +LanguageServer::Protocol::Constant::CodeActionKind::REFACTOR = T.let(T.unsafe(nil), String) + +# Base kind for refactoring extraction actions: 'refactor.extract'. +# +# Example extract actions: +# +# - Extract method +# - Extract function +# - Extract variable +# - Extract interface from class +# - ... +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#38 +LanguageServer::Protocol::Constant::CodeActionKind::REFACTOR_EXTRACT = T.let(T.unsafe(nil), String) + +# Base kind for refactoring inline actions: 'refactor.inline'. +# +# Example inline actions: +# +# - Inline function +# - Inline variable +# - Inline constant +# - ... +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#49 +LanguageServer::Protocol::Constant::CodeActionKind::REFACTOR_INLINE = T.let(T.unsafe(nil), String) + +# Base kind for refactoring rewrite actions: 'refactor.rewrite'. +# +# Example rewrite actions: +# +# - Convert JavaScript function to class +# - Add or remove parameter +# - Encapsulate field +# - Make method static +# - Move method to base class +# - ... +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#62 +LanguageServer::Protocol::Constant::CodeActionKind::REFACTOR_REWRITE = T.let(T.unsafe(nil), String) + +# Base kind for source actions: `source`. +# +# Source code actions apply to the entire file. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#68 +LanguageServer::Protocol::Constant::CodeActionKind::SOURCE = T.let(T.unsafe(nil), String) + +# Base kind for a 'fix all' source action: `source.fixAll`. +# +# 'Fix all' actions automatically fix errors that have a clear fix that +# do not require user input. They should not suppress errors or perform +# unsafe fixes such as generating new types or classes. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#81 +LanguageServer::Protocol::Constant::CodeActionKind::SOURCE_FIX_ALL = T.let(T.unsafe(nil), String) + +# Base kind for an organize imports source action: +# `source.organizeImports`. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_kind.rb#73 +LanguageServer::Protocol::Constant::CodeActionKind::SOURCE_ORGANIZE_IMPORTS = T.let(T.unsafe(nil), String) + +# The reason why code actions were requested. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_trigger_kind.rb#7 +module LanguageServer::Protocol::Constant::CodeActionTriggerKind; end + +# Code actions were requested automatically. +# +# This typically happens when current selection in a file changes, but can +# also be triggered when file content changes. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_trigger_kind.rb#18 +LanguageServer::Protocol::Constant::CodeActionTriggerKind::AUTOMATIC = T.let(T.unsafe(nil), Integer) + +# Code actions were explicitly requested by the user or by an extension. +# +# source://language_server-protocol//lib/language_server/protocol/constant/code_action_trigger_kind.rb#11 +LanguageServer::Protocol::Constant::CodeActionTriggerKind::INVOKED = T.let(T.unsafe(nil), Integer) + +# The kind of a completion entry. +# +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#7 +module LanguageServer::Protocol::Constant::CompletionItemKind; end + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#14 +LanguageServer::Protocol::Constant::CompletionItemKind::CLASS = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#23 +LanguageServer::Protocol::Constant::CompletionItemKind::COLOR = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#28 +LanguageServer::Protocol::Constant::CompletionItemKind::CONSTANT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#11 +LanguageServer::Protocol::Constant::CompletionItemKind::CONSTRUCTOR = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#20 +LanguageServer::Protocol::Constant::CompletionItemKind::ENUM = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#27 +LanguageServer::Protocol::Constant::CompletionItemKind::ENUM_MEMBER = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#30 +LanguageServer::Protocol::Constant::CompletionItemKind::EVENT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#12 +LanguageServer::Protocol::Constant::CompletionItemKind::FIELD = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#24 +LanguageServer::Protocol::Constant::CompletionItemKind::FILE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#26 +LanguageServer::Protocol::Constant::CompletionItemKind::FOLDER = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#10 +LanguageServer::Protocol::Constant::CompletionItemKind::FUNCTION = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#15 +LanguageServer::Protocol::Constant::CompletionItemKind::INTERFACE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#21 +LanguageServer::Protocol::Constant::CompletionItemKind::KEYWORD = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#9 +LanguageServer::Protocol::Constant::CompletionItemKind::METHOD = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#16 +LanguageServer::Protocol::Constant::CompletionItemKind::MODULE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#31 +LanguageServer::Protocol::Constant::CompletionItemKind::OPERATOR = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#17 +LanguageServer::Protocol::Constant::CompletionItemKind::PROPERTY = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#25 +LanguageServer::Protocol::Constant::CompletionItemKind::REFERENCE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#22 +LanguageServer::Protocol::Constant::CompletionItemKind::SNIPPET = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#29 +LanguageServer::Protocol::Constant::CompletionItemKind::STRUCT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#8 +LanguageServer::Protocol::Constant::CompletionItemKind::TEXT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#32 +LanguageServer::Protocol::Constant::CompletionItemKind::TYPE_PARAMETER = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#18 +LanguageServer::Protocol::Constant::CompletionItemKind::UNIT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#19 +LanguageServer::Protocol::Constant::CompletionItemKind::VALUE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_kind.rb#13 +LanguageServer::Protocol::Constant::CompletionItemKind::VARIABLE = T.let(T.unsafe(nil), Integer) + +# Completion item tags are extra annotations that tweak the rendering of a +# completion item. +# +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_tag.rb#8 +module LanguageServer::Protocol::Constant::CompletionItemTag; end + +# Render a completion as obsolete, usually using a strike-out. +# +# source://language_server-protocol//lib/language_server/protocol/constant/completion_item_tag.rb#12 +LanguageServer::Protocol::Constant::CompletionItemTag::DEPRECATED = T.let(T.unsafe(nil), Integer) + +# How a completion was triggered +# +# source://language_server-protocol//lib/language_server/protocol/constant/completion_trigger_kind.rb#7 +module LanguageServer::Protocol::Constant::CompletionTriggerKind; end + +# Completion was triggered by typing an identifier (24x7 code +# complete), manual invocation (e.g Ctrl+Space) or via API. +# +# source://language_server-protocol//lib/language_server/protocol/constant/completion_trigger_kind.rb#12 +LanguageServer::Protocol::Constant::CompletionTriggerKind::INVOKED = T.let(T.unsafe(nil), Integer) + +# Completion was triggered by a trigger character specified by +# the `triggerCharacters` properties of the +# `CompletionRegistrationOptions`. +# +# source://language_server-protocol//lib/language_server/protocol/constant/completion_trigger_kind.rb#18 +LanguageServer::Protocol::Constant::CompletionTriggerKind::TRIGGER_CHARACTER = T.let(T.unsafe(nil), Integer) + +# Completion was re-triggered as the current completion list is incomplete. +# +# source://language_server-protocol//lib/language_server/protocol/constant/completion_trigger_kind.rb#22 +LanguageServer::Protocol::Constant::CompletionTriggerKind::TRIGGER_FOR_INCOMPLETE_COMPLETIONS = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_severity.rb#4 +module LanguageServer::Protocol::Constant::DiagnosticSeverity; end + +# Reports an error. +# +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_severity.rb#8 +LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR = T.let(T.unsafe(nil), Integer) + +# Reports a hint. +# +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_severity.rb#20 +LanguageServer::Protocol::Constant::DiagnosticSeverity::HINT = T.let(T.unsafe(nil), Integer) + +# Reports an information. +# +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_severity.rb#16 +LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION = T.let(T.unsafe(nil), Integer) + +# Reports a warning. +# +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_severity.rb#12 +LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING = T.let(T.unsafe(nil), Integer) + +# The diagnostic tags. +# +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_tag.rb#7 +module LanguageServer::Protocol::Constant::DiagnosticTag; end + +# Deprecated or obsolete code. +# +# Clients are allowed to rendered diagnostics with this tag strike through. +# +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_tag.rb#20 +LanguageServer::Protocol::Constant::DiagnosticTag::DEPRECATED = T.let(T.unsafe(nil), Integer) + +# Unused or unnecessary code. +# +# Clients are allowed to render diagnostics with this tag faded out +# instead of having an error squiggle. +# +# source://language_server-protocol//lib/language_server/protocol/constant/diagnostic_tag.rb#14 +LanguageServer::Protocol::Constant::DiagnosticTag::UNNECESSARY = T.let(T.unsafe(nil), Integer) + +# The document diagnostic report kinds. +# +# source://language_server-protocol//lib/language_server/protocol/constant/document_diagnostic_report_kind.rb#7 +module LanguageServer::Protocol::Constant::DocumentDiagnosticReportKind; end + +# A diagnostic report with a full +# set of problems. +# +# source://language_server-protocol//lib/language_server/protocol/constant/document_diagnostic_report_kind.rb#12 +LanguageServer::Protocol::Constant::DocumentDiagnosticReportKind::FULL = T.let(T.unsafe(nil), String) + +# A report indicating that the last +# returned report is still accurate. +# +# source://language_server-protocol//lib/language_server/protocol/constant/document_diagnostic_report_kind.rb#17 +LanguageServer::Protocol::Constant::DocumentDiagnosticReportKind::UNCHANGED = T.let(T.unsafe(nil), String) + +# A document highlight kind. +# +# source://language_server-protocol//lib/language_server/protocol/constant/document_highlight_kind.rb#7 +module LanguageServer::Protocol::Constant::DocumentHighlightKind; end + +# Read-access of a symbol, like reading a variable. +# +# source://language_server-protocol//lib/language_server/protocol/constant/document_highlight_kind.rb#15 +LanguageServer::Protocol::Constant::DocumentHighlightKind::READ = T.let(T.unsafe(nil), Integer) + +# A textual occurrence. +# +# source://language_server-protocol//lib/language_server/protocol/constant/document_highlight_kind.rb#11 +LanguageServer::Protocol::Constant::DocumentHighlightKind::TEXT = T.let(T.unsafe(nil), Integer) + +# Write-access of a symbol, like writing to a variable. +# +# source://language_server-protocol//lib/language_server/protocol/constant/document_highlight_kind.rb#19 +LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#4 +module LanguageServer::Protocol::Constant::ErrorCodes; end + +# The server detected that the content of a document got +# modified outside normal conditions. A server should +# NOT send this error code if it detects a content change +# in it unprocessed messages. The result even computed +# on an older state might still be useful for the client. +# +# If a client decides that a result is not of any use anymore +# the client should cancel the request. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#59 +LanguageServer::Protocol::Constant::ErrorCodes::CONTENT_MODIFIED = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#9 +LanguageServer::Protocol::Constant::ErrorCodes::INTERNAL_ERROR = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#8 +LanguageServer::Protocol::Constant::ErrorCodes::INVALID_PARAMS = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#6 +LanguageServer::Protocol::Constant::ErrorCodes::INVALID_REQUEST = T.let(T.unsafe(nil), Integer) + +# This is the end range of JSON-RPC reserved error codes. +# It doesn't denote a real error code. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#29 +LanguageServer::Protocol::Constant::ErrorCodes::JSONRPC_RESERVED_ERROR_RANGE_END = T.let(T.unsafe(nil), Integer) + +# This is the start range of JSON-RPC reserved error codes. +# It doesn't denote a real error code. No LSP error codes should +# be defined between the start and end range. For backwards +# compatibility the `ServerNotInitialized` and the `UnknownErrorCode` +# are left in the range. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#17 +LanguageServer::Protocol::Constant::ErrorCodes::JSONRPC_RESERVED_ERROR_RANGE_START = T.let(T.unsafe(nil), Integer) + +# This is the end range of LSP reserved error codes. +# It doesn't denote a real error code. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#69 +LanguageServer::Protocol::Constant::ErrorCodes::LSP_RESERVED_ERROR_RANGE_END = T.let(T.unsafe(nil), Integer) + +# This is the start range of LSP reserved error codes. +# It doesn't denote a real error code. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#35 +LanguageServer::Protocol::Constant::ErrorCodes::LSP_RESERVED_ERROR_RANGE_START = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#7 +LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#5 +LanguageServer::Protocol::Constant::ErrorCodes::PARSE_ERROR = T.let(T.unsafe(nil), Integer) + +# The client has canceled a request and a server as detected +# the cancel. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#64 +LanguageServer::Protocol::Constant::ErrorCodes::REQUEST_CANCELLED = T.let(T.unsafe(nil), Integer) + +# A request failed but it was syntactically correct, e.g the +# method name was known and the parameters were valid. The error +# message should contain human readable information about why +# the request failed. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#42 +LanguageServer::Protocol::Constant::ErrorCodes::REQUEST_FAILED = T.let(T.unsafe(nil), Integer) + +# The server cancelled the request. This error code should +# only be used for requests that explicitly support being +# server cancellable. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#48 +LanguageServer::Protocol::Constant::ErrorCodes::SERVER_CANCELLED = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#30 +LanguageServer::Protocol::Constant::ErrorCodes::SERVER_ERROR_END = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#18 +LanguageServer::Protocol::Constant::ErrorCodes::SERVER_ERROR_START = T.let(T.unsafe(nil), Integer) + +# Error code indicating that a server received a notification or +# request before the server has received the `initialize` request. +# +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#23 +LanguageServer::Protocol::Constant::ErrorCodes::SERVER_NOT_INITIALIZED = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/error_codes.rb#24 +LanguageServer::Protocol::Constant::ErrorCodes::UNKNOWN_ERROR_CODE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/failure_handling_kind.rb#4 +module LanguageServer::Protocol::Constant::FailureHandlingKind; end + +# Applying the workspace change is simply aborted if one of the changes +# provided fails. All operations executed before the failing operation +# stay executed. +# +# source://language_server-protocol//lib/language_server/protocol/constant/failure_handling_kind.rb#10 +LanguageServer::Protocol::Constant::FailureHandlingKind::ABORT = T.let(T.unsafe(nil), String) + +# If the workspace edit contains only textual file changes they are +# executed transactional. If resource changes (create, rename or delete +# file) are part of the change the failure handling strategy is abort. +# +# source://language_server-protocol//lib/language_server/protocol/constant/failure_handling_kind.rb#21 +LanguageServer::Protocol::Constant::FailureHandlingKind::TEXT_ONLY_TRANSACTIONAL = T.let(T.unsafe(nil), String) + +# All operations are executed transactional. That means they either all +# succeed or no changes at all are applied to the workspace. +# +# source://language_server-protocol//lib/language_server/protocol/constant/failure_handling_kind.rb#15 +LanguageServer::Protocol::Constant::FailureHandlingKind::TRANSACTIONAL = T.let(T.unsafe(nil), String) + +# The client tries to undo the operations already executed. But there is no +# guarantee that this is succeeding. +# +# source://language_server-protocol//lib/language_server/protocol/constant/failure_handling_kind.rb#26 +LanguageServer::Protocol::Constant::FailureHandlingKind::UNDO = T.let(T.unsafe(nil), String) + +# The file event type. +# +# source://language_server-protocol//lib/language_server/protocol/constant/file_change_type.rb#7 +module LanguageServer::Protocol::Constant::FileChangeType; end + +# The file got changed. +# +# source://language_server-protocol//lib/language_server/protocol/constant/file_change_type.rb#15 +LanguageServer::Protocol::Constant::FileChangeType::CHANGED = T.let(T.unsafe(nil), Integer) + +# The file got created. +# +# source://language_server-protocol//lib/language_server/protocol/constant/file_change_type.rb#11 +LanguageServer::Protocol::Constant::FileChangeType::CREATED = T.let(T.unsafe(nil), Integer) + +# The file got deleted. +# +# source://language_server-protocol//lib/language_server/protocol/constant/file_change_type.rb#19 +LanguageServer::Protocol::Constant::FileChangeType::DELETED = T.let(T.unsafe(nil), Integer) + +# A pattern kind describing if a glob pattern matches a file a folder or +# both. +# +# source://language_server-protocol//lib/language_server/protocol/constant/file_operation_pattern_kind.rb#8 +module LanguageServer::Protocol::Constant::FileOperationPatternKind; end + +# The pattern matches a file only. +# +# source://language_server-protocol//lib/language_server/protocol/constant/file_operation_pattern_kind.rb#12 +LanguageServer::Protocol::Constant::FileOperationPatternKind::FILE = T.let(T.unsafe(nil), String) + +# The pattern matches a folder only. +# +# source://language_server-protocol//lib/language_server/protocol/constant/file_operation_pattern_kind.rb#16 +LanguageServer::Protocol::Constant::FileOperationPatternKind::FOLDER = T.let(T.unsafe(nil), String) + +# A set of predefined range kinds. +# The type is a string since the value set is extensible +# +# source://language_server-protocol//lib/language_server/protocol/constant/folding_range_kind.rb#8 +module LanguageServer::Protocol::Constant::FoldingRangeKind; end + +# Folding range for a comment +# +# source://language_server-protocol//lib/language_server/protocol/constant/folding_range_kind.rb#12 +LanguageServer::Protocol::Constant::FoldingRangeKind::COMMENT = T.let(T.unsafe(nil), String) + +# Folding range for imports or includes +# +# source://language_server-protocol//lib/language_server/protocol/constant/folding_range_kind.rb#16 +LanguageServer::Protocol::Constant::FoldingRangeKind::IMPORTS = T.let(T.unsafe(nil), String) + +# Folding range for a region (e.g. `#region`) +# +# source://language_server-protocol//lib/language_server/protocol/constant/folding_range_kind.rb#20 +LanguageServer::Protocol::Constant::FoldingRangeKind::REGION = T.let(T.unsafe(nil), String) + +# Known error codes for an `InitializeErrorCodes`; +# +# source://language_server-protocol//lib/language_server/protocol/constant/initialize_error_codes.rb#7 +module LanguageServer::Protocol::Constant::InitializeErrorCodes; end + +# If the protocol version provided by the client can't be handled by +# the server. +# +# source://language_server-protocol//lib/language_server/protocol/constant/initialize_error_codes.rb#12 +LanguageServer::Protocol::Constant::InitializeErrorCodes::UNKNOWN_PROTOCOL_VERSION = T.let(T.unsafe(nil), Integer) + +# Inlay hint kinds. +# +# source://language_server-protocol//lib/language_server/protocol/constant/inlay_hint_kind.rb#7 +module LanguageServer::Protocol::Constant::InlayHintKind; end + +# An inlay hint that is for a parameter. +# +# source://language_server-protocol//lib/language_server/protocol/constant/inlay_hint_kind.rb#15 +LanguageServer::Protocol::Constant::InlayHintKind::PARAMETER = T.let(T.unsafe(nil), Integer) + +# An inlay hint that for a type annotation. +# +# source://language_server-protocol//lib/language_server/protocol/constant/inlay_hint_kind.rb#11 +LanguageServer::Protocol::Constant::InlayHintKind::TYPE = T.let(T.unsafe(nil), Integer) + +# Defines whether the insert text in a completion item should be interpreted as +# plain text or a snippet. +# +# source://language_server-protocol//lib/language_server/protocol/constant/insert_text_format.rb#8 +module LanguageServer::Protocol::Constant::InsertTextFormat; end + +# The primary text to be inserted is treated as a plain string. +# +# source://language_server-protocol//lib/language_server/protocol/constant/insert_text_format.rb#12 +LanguageServer::Protocol::Constant::InsertTextFormat::PLAIN_TEXT = T.let(T.unsafe(nil), Integer) + +# The primary text to be inserted is treated as a snippet. +# +# A snippet can define tab stops and placeholders with `$1`, `$2` +# and `${3:foo}`. `$0` defines the final tab stop, it defaults to +# the end of the snippet. Placeholders with equal identifiers are linked, +# that is typing in one will update others too. +# +# source://language_server-protocol//lib/language_server/protocol/constant/insert_text_format.rb#21 +LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET = T.let(T.unsafe(nil), Integer) + +# How whitespace and indentation is handled during completion +# item insertion. +# +# source://language_server-protocol//lib/language_server/protocol/constant/insert_text_mode.rb#8 +module LanguageServer::Protocol::Constant::InsertTextMode; end + +# The editor adjusts leading whitespace of new lines so that +# they match the indentation up to the cursor of the line for +# which the item is accepted. +# +# Consider a line like this: <2tabs><3tabs>foo. Accepting a +# multi line completion item is indented using 2 tabs and all +# following lines inserted will be indented using 2 tabs as well. +# +# source://language_server-protocol//lib/language_server/protocol/constant/insert_text_mode.rb#26 +LanguageServer::Protocol::Constant::InsertTextMode::ADJUST_INDENTATION = T.let(T.unsafe(nil), Integer) + +# The insertion or replace strings is taken as it is. If the +# value is multi line the lines below the cursor will be +# inserted using the indentation defined in the string value. +# The client will not apply any kind of adjustments to the +# string. +# +# source://language_server-protocol//lib/language_server/protocol/constant/insert_text_mode.rb#16 +LanguageServer::Protocol::Constant::InsertTextMode::AS_IS = T.let(T.unsafe(nil), Integer) + +# Describes the content type that a client supports in various +# result literals like `Hover`, `ParameterInfo` or `CompletionItem`. +# +# Please note that `MarkupKinds` must not start with a `$`. This kinds +# are reserved for internal usage. +# +# source://language_server-protocol//lib/language_server/protocol/constant/markup_kind.rb#11 +module LanguageServer::Protocol::Constant::MarkupKind; end + +# Markdown is supported as a content format +# +# source://language_server-protocol//lib/language_server/protocol/constant/markup_kind.rb#19 +LanguageServer::Protocol::Constant::MarkupKind::MARKDOWN = T.let(T.unsafe(nil), String) + +# Plain text is supported as a content format +# +# source://language_server-protocol//lib/language_server/protocol/constant/markup_kind.rb#15 +LanguageServer::Protocol::Constant::MarkupKind::PLAIN_TEXT = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/message_type.rb#4 +module LanguageServer::Protocol::Constant::MessageType; end + +# An error message. +# +# source://language_server-protocol//lib/language_server/protocol/constant/message_type.rb#8 +LanguageServer::Protocol::Constant::MessageType::ERROR = T.let(T.unsafe(nil), Integer) + +# An information message. +# +# source://language_server-protocol//lib/language_server/protocol/constant/message_type.rb#16 +LanguageServer::Protocol::Constant::MessageType::INFO = T.let(T.unsafe(nil), Integer) + +# A log message. +# +# source://language_server-protocol//lib/language_server/protocol/constant/message_type.rb#20 +LanguageServer::Protocol::Constant::MessageType::LOG = T.let(T.unsafe(nil), Integer) + +# A warning message. +# +# source://language_server-protocol//lib/language_server/protocol/constant/message_type.rb#12 +LanguageServer::Protocol::Constant::MessageType::WARNING = T.let(T.unsafe(nil), Integer) + +# The moniker kind. +# +# source://language_server-protocol//lib/language_server/protocol/constant/moniker_kind.rb#7 +module LanguageServer::Protocol::Constant::MonikerKind; end + +# The moniker represents a symbol that is exported from a project +# +# source://language_server-protocol//lib/language_server/protocol/constant/moniker_kind.rb#15 +LanguageServer::Protocol::Constant::MonikerKind::EXPORT = T.let(T.unsafe(nil), String) + +# The moniker represent a symbol that is imported into a project +# +# source://language_server-protocol//lib/language_server/protocol/constant/moniker_kind.rb#11 +LanguageServer::Protocol::Constant::MonikerKind::IMPORT = T.let(T.unsafe(nil), String) + +# The moniker represents a symbol that is local to a project (e.g. a local +# variable of a function, a class not visible outside the project, ...) +# +# source://language_server-protocol//lib/language_server/protocol/constant/moniker_kind.rb#20 +LanguageServer::Protocol::Constant::MonikerKind::LOCAL = T.let(T.unsafe(nil), String) + +# A notebook cell kind. +# +# source://language_server-protocol//lib/language_server/protocol/constant/notebook_cell_kind.rb#7 +module LanguageServer::Protocol::Constant::NotebookCellKind; end + +# A code-cell is source code. +# +# source://language_server-protocol//lib/language_server/protocol/constant/notebook_cell_kind.rb#15 +LanguageServer::Protocol::Constant::NotebookCellKind::CODE = T.let(T.unsafe(nil), Integer) + +# A markup-cell is formatted source that is used for display. +# +# source://language_server-protocol//lib/language_server/protocol/constant/notebook_cell_kind.rb#11 +LanguageServer::Protocol::Constant::NotebookCellKind::MARKUP = T.let(T.unsafe(nil), Integer) + +# A type indicating how positions are encoded, +# specifically what column offsets mean. +# A set of predefined position encoding kinds. +# +# source://language_server-protocol//lib/language_server/protocol/constant/position_encoding_kind.rb#9 +module LanguageServer::Protocol::Constant::PositionEncodingKind; end + +# Character offsets count UTF-16 code units. +# +# This is the default and must always be supported +# by servers +# +# source://language_server-protocol//lib/language_server/protocol/constant/position_encoding_kind.rb#20 +LanguageServer::Protocol::Constant::PositionEncodingKind::UTF16 = T.let(T.unsafe(nil), String) + +# Character offsets count UTF-32 code units. +# +# Implementation note: these are the same as Unicode code points, +# so this `PositionEncodingKind` may also be used for an +# encoding-agnostic representation of character offsets. +# +# source://language_server-protocol//lib/language_server/protocol/constant/position_encoding_kind.rb#28 +LanguageServer::Protocol::Constant::PositionEncodingKind::UTF32 = T.let(T.unsafe(nil), String) + +# Character offsets count UTF-8 code units (e.g bytes). +# +# source://language_server-protocol//lib/language_server/protocol/constant/position_encoding_kind.rb#13 +LanguageServer::Protocol::Constant::PositionEncodingKind::UTF8 = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/prepare_support_default_behavior.rb#4 +module LanguageServer::Protocol::Constant::PrepareSupportDefaultBehavior; end + +# The client's default behavior is to select the identifier +# according to the language's syntax rule. +# +# source://language_server-protocol//lib/language_server/protocol/constant/prepare_support_default_behavior.rb#9 +LanguageServer::Protocol::Constant::PrepareSupportDefaultBehavior::IDENTIFIER = T.let(T.unsafe(nil), Integer) + +# The kind of resource operations supported by the client. +# +# source://language_server-protocol//lib/language_server/protocol/constant/resource_operation_kind.rb#7 +module LanguageServer::Protocol::Constant::ResourceOperationKind; end + +# Supports creating new files and folders. +# +# source://language_server-protocol//lib/language_server/protocol/constant/resource_operation_kind.rb#11 +LanguageServer::Protocol::Constant::ResourceOperationKind::CREATE = T.let(T.unsafe(nil), String) + +# Supports deleting existing files and folders. +# +# source://language_server-protocol//lib/language_server/protocol/constant/resource_operation_kind.rb#19 +LanguageServer::Protocol::Constant::ResourceOperationKind::DELETE = T.let(T.unsafe(nil), String) + +# Supports renaming existing files and folders. +# +# source://language_server-protocol//lib/language_server/protocol/constant/resource_operation_kind.rb#15 +LanguageServer::Protocol::Constant::ResourceOperationKind::RENAME = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#4 +module LanguageServer::Protocol::Constant::SemanticTokenModifiers; end + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#10 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::ABSTRACT = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#11 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::ASYNC = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#5 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::DECLARATION = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#14 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::DEFAULT_LIBRARY = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#6 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::DEFINITION = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#9 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::DEPRECATED = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#13 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::DOCUMENTATION = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#12 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::MODIFICATION = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#7 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::READONLY = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_modifiers.rb#8 +LanguageServer::Protocol::Constant::SemanticTokenModifiers::STATIC = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#4 +module LanguageServer::Protocol::Constant::SemanticTokenTypes; end + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#11 +LanguageServer::Protocol::Constant::SemanticTokenTypes::CLASS = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#26 +LanguageServer::Protocol::Constant::SemanticTokenTypes::COMMENT = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#31 +LanguageServer::Protocol::Constant::SemanticTokenTypes::DECORATOR = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#12 +LanguageServer::Protocol::Constant::SemanticTokenTypes::ENUM = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#19 +LanguageServer::Protocol::Constant::SemanticTokenTypes::ENUM_MEMBER = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#20 +LanguageServer::Protocol::Constant::SemanticTokenTypes::EVENT = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#21 +LanguageServer::Protocol::Constant::SemanticTokenTypes::FUNCTION = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#13 +LanguageServer::Protocol::Constant::SemanticTokenTypes::INTERFACE = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#24 +LanguageServer::Protocol::Constant::SemanticTokenTypes::KEYWORD = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#23 +LanguageServer::Protocol::Constant::SemanticTokenTypes::MACRO = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#22 +LanguageServer::Protocol::Constant::SemanticTokenTypes::METHOD = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#25 +LanguageServer::Protocol::Constant::SemanticTokenTypes::MODIFIER = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#5 +LanguageServer::Protocol::Constant::SemanticTokenTypes::NAMESPACE = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#28 +LanguageServer::Protocol::Constant::SemanticTokenTypes::NUMBER = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#30 +LanguageServer::Protocol::Constant::SemanticTokenTypes::OPERATOR = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#16 +LanguageServer::Protocol::Constant::SemanticTokenTypes::PARAMETER = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#18 +LanguageServer::Protocol::Constant::SemanticTokenTypes::PROPERTY = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#29 +LanguageServer::Protocol::Constant::SemanticTokenTypes::REGEXP = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#27 +LanguageServer::Protocol::Constant::SemanticTokenTypes::STRING = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#14 +LanguageServer::Protocol::Constant::SemanticTokenTypes::STRUCT = T.let(T.unsafe(nil), String) + +# Represents a generic type. Acts as a fallback for types which +# can't be mapped to a specific type like class or enum. +# +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#10 +LanguageServer::Protocol::Constant::SemanticTokenTypes::TYPE = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#15 +LanguageServer::Protocol::Constant::SemanticTokenTypes::TYPE_PARAMETER = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/semantic_token_types.rb#17 +LanguageServer::Protocol::Constant::SemanticTokenTypes::VARIABLE = T.let(T.unsafe(nil), String) + +# How a signature help was triggered. +# +# source://language_server-protocol//lib/language_server/protocol/constant/signature_help_trigger_kind.rb#7 +module LanguageServer::Protocol::Constant::SignatureHelpTriggerKind; end + +# Signature help was triggered by the cursor moving or by the document +# content changing. +# +# source://language_server-protocol//lib/language_server/protocol/constant/signature_help_trigger_kind.rb#20 +LanguageServer::Protocol::Constant::SignatureHelpTriggerKind::CONTENT_CHANGE = T.let(T.unsafe(nil), Integer) + +# Signature help was invoked manually by the user or by a command. +# +# source://language_server-protocol//lib/language_server/protocol/constant/signature_help_trigger_kind.rb#11 +LanguageServer::Protocol::Constant::SignatureHelpTriggerKind::INVOKED = T.let(T.unsafe(nil), Integer) + +# Signature help was triggered by a trigger character. +# +# source://language_server-protocol//lib/language_server/protocol/constant/signature_help_trigger_kind.rb#15 +LanguageServer::Protocol::Constant::SignatureHelpTriggerKind::TRIGGER_CHARACTER = T.let(T.unsafe(nil), Integer) + +# A symbol kind. +# +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#7 +module LanguageServer::Protocol::Constant::SymbolKind; end + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#25 +LanguageServer::Protocol::Constant::SymbolKind::ARRAY = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#24 +LanguageServer::Protocol::Constant::SymbolKind::BOOLEAN = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#12 +LanguageServer::Protocol::Constant::SymbolKind::CLASS = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#21 +LanguageServer::Protocol::Constant::SymbolKind::CONSTANT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#16 +LanguageServer::Protocol::Constant::SymbolKind::CONSTRUCTOR = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#17 +LanguageServer::Protocol::Constant::SymbolKind::ENUM = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#29 +LanguageServer::Protocol::Constant::SymbolKind::ENUM_MEMBER = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#31 +LanguageServer::Protocol::Constant::SymbolKind::EVENT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#15 +LanguageServer::Protocol::Constant::SymbolKind::FIELD = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#8 +LanguageServer::Protocol::Constant::SymbolKind::FILE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#19 +LanguageServer::Protocol::Constant::SymbolKind::FUNCTION = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#18 +LanguageServer::Protocol::Constant::SymbolKind::INTERFACE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#27 +LanguageServer::Protocol::Constant::SymbolKind::KEY = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#13 +LanguageServer::Protocol::Constant::SymbolKind::METHOD = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#9 +LanguageServer::Protocol::Constant::SymbolKind::MODULE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#10 +LanguageServer::Protocol::Constant::SymbolKind::NAMESPACE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#28 +LanguageServer::Protocol::Constant::SymbolKind::NULL = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#23 +LanguageServer::Protocol::Constant::SymbolKind::NUMBER = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#26 +LanguageServer::Protocol::Constant::SymbolKind::OBJECT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#32 +LanguageServer::Protocol::Constant::SymbolKind::OPERATOR = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#11 +LanguageServer::Protocol::Constant::SymbolKind::PACKAGE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#14 +LanguageServer::Protocol::Constant::SymbolKind::PROPERTY = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#22 +LanguageServer::Protocol::Constant::SymbolKind::STRING = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#30 +LanguageServer::Protocol::Constant::SymbolKind::STRUCT = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#33 +LanguageServer::Protocol::Constant::SymbolKind::TYPE_PARAMETER = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_kind.rb#20 +LanguageServer::Protocol::Constant::SymbolKind::VARIABLE = T.let(T.unsafe(nil), Integer) + +# Symbol tags are extra annotations that tweak the rendering of a symbol. +# +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_tag.rb#7 +module LanguageServer::Protocol::Constant::SymbolTag; end + +# Render a symbol as obsolete, usually using a strike-out. +# +# source://language_server-protocol//lib/language_server/protocol/constant/symbol_tag.rb#11 +LanguageServer::Protocol::Constant::SymbolTag::DEPRECATED = T.let(T.unsafe(nil), Integer) + +# Represents reasons why a text document is saved. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_save_reason.rb#7 +module LanguageServer::Protocol::Constant::TextDocumentSaveReason; end + +# Automatic after a delay. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_save_reason.rb#16 +LanguageServer::Protocol::Constant::TextDocumentSaveReason::AFTER_DELAY = T.let(T.unsafe(nil), Integer) + +# When the editor lost focus. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_save_reason.rb#20 +LanguageServer::Protocol::Constant::TextDocumentSaveReason::FOCUS_OUT = T.let(T.unsafe(nil), Integer) + +# Manually triggered, e.g. by the user pressing save, by starting +# debugging, or by an API call. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_save_reason.rb#12 +LanguageServer::Protocol::Constant::TextDocumentSaveReason::MANUAL = T.let(T.unsafe(nil), Integer) + +# Defines how the host (editor) should sync document changes to the language +# server. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_sync_kind.rb#8 +module LanguageServer::Protocol::Constant::TextDocumentSyncKind; end + +# Documents are synced by always sending the full content +# of the document. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_sync_kind.rb#17 +LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL = T.let(T.unsafe(nil), Integer) + +# Documents are synced by sending the full content on open. +# After that only incremental updates to the document are +# sent. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_sync_kind.rb#23 +LanguageServer::Protocol::Constant::TextDocumentSyncKind::INCREMENTAL = T.let(T.unsafe(nil), Integer) + +# Documents should not be synced at all. +# +# source://language_server-protocol//lib/language_server/protocol/constant/text_document_sync_kind.rb#12 +LanguageServer::Protocol::Constant::TextDocumentSyncKind::NONE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/constant/token_format.rb#4 +module LanguageServer::Protocol::Constant::TokenFormat; end + +# source://language_server-protocol//lib/language_server/protocol/constant/token_format.rb#5 +LanguageServer::Protocol::Constant::TokenFormat::RELATIVE = T.let(T.unsafe(nil), String) + +# Moniker uniqueness level to define scope of the moniker. +# +# source://language_server-protocol//lib/language_server/protocol/constant/uniqueness_level.rb#7 +module LanguageServer::Protocol::Constant::UniquenessLevel; end + +# The moniker is only unique inside a document +# +# source://language_server-protocol//lib/language_server/protocol/constant/uniqueness_level.rb#11 +LanguageServer::Protocol::Constant::UniquenessLevel::DOCUMENT = T.let(T.unsafe(nil), String) + +# The moniker is globally unique +# +# source://language_server-protocol//lib/language_server/protocol/constant/uniqueness_level.rb#27 +LanguageServer::Protocol::Constant::UniquenessLevel::GLOBAL = T.let(T.unsafe(nil), String) + +# The moniker is unique inside the group to which a project belongs +# +# source://language_server-protocol//lib/language_server/protocol/constant/uniqueness_level.rb#19 +LanguageServer::Protocol::Constant::UniquenessLevel::GROUP = T.let(T.unsafe(nil), String) + +# The moniker is unique inside a project for which a dump got created +# +# source://language_server-protocol//lib/language_server/protocol/constant/uniqueness_level.rb#15 +LanguageServer::Protocol::Constant::UniquenessLevel::PROJECT = T.let(T.unsafe(nil), String) + +# The moniker is unique inside the moniker scheme. +# +# source://language_server-protocol//lib/language_server/protocol/constant/uniqueness_level.rb#23 +LanguageServer::Protocol::Constant::UniquenessLevel::SCHEME = T.let(T.unsafe(nil), String) + +# source://language_server-protocol//lib/language_server/protocol/constant/watch_kind.rb#4 +module LanguageServer::Protocol::Constant::WatchKind; end + +# Interested in change events +# +# source://language_server-protocol//lib/language_server/protocol/constant/watch_kind.rb#12 +LanguageServer::Protocol::Constant::WatchKind::CHANGE = T.let(T.unsafe(nil), Integer) + +# Interested in create events. +# +# source://language_server-protocol//lib/language_server/protocol/constant/watch_kind.rb#8 +LanguageServer::Protocol::Constant::WatchKind::CREATE = T.let(T.unsafe(nil), Integer) + +# Interested in delete events +# +# source://language_server-protocol//lib/language_server/protocol/constant/watch_kind.rb#16 +LanguageServer::Protocol::Constant::WatchKind::DELETE = T.let(T.unsafe(nil), Integer) + +# source://language_server-protocol//lib/language_server/protocol/interface.rb#3 +module LanguageServer::Protocol::Interface; end + +# A special text edit with an additional change annotation. +# +# source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#7 +class LanguageServer::Protocol::Interface::AnnotatedTextEdit + # @return [AnnotatedTextEdit] a new instance of AnnotatedTextEdit + # + # source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#8 + def initialize(range:, new_text:, annotation_id:); end + + # The actual annotation identifier. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#40 + def annotation_id; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#44 + def attributes; end + + # The string to be inserted. For delete operations use an + # empty string. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#32 + def new_text; end + + # The range of the text document to be manipulated. To insert + # text into a document create a range where start === end. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#23 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/annotated_text_edit.rb#50 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_params.rb#4 +class LanguageServer::Protocol::Interface::ApplyWorkspaceEditParams + # @return [ApplyWorkspaceEditParams] a new instance of ApplyWorkspaceEditParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_params.rb#5 + def initialize(edit:, label: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_params.rb#32 + def attributes; end + + # The edits to apply. + # + # @return [WorkspaceEdit] + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_params.rb#28 + def edit; end + + # An optional label of the workspace edit. This label is + # presented in the user interface for example on an undo + # stack to undo the workspace edit. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_params.rb#20 + def label; end + + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_params.rb#34 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_params.rb#38 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#4 +class LanguageServer::Protocol::Interface::ApplyWorkspaceEditResult + # @return [ApplyWorkspaceEditResult] a new instance of ApplyWorkspaceEditResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#5 + def initialize(applied:, failure_reason: T.unsafe(nil), failed_change: T.unsafe(nil)); end + + # Indicates whether the edit was applied or not. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#19 + def applied; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#44 + def attributes; end + + # Depending on the client's failure handling strategy `failedChange` + # might contain the index of the change that failed. This property is + # only available if the client signals a `failureHandling` strategy + # in its client capabilities. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#40 + def failed_change; end + + # An optional textual description for why the edit was not applied. + # This may be used by the server for diagnostic logging or to provide + # a suitable error for a request that triggered the edit. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#29 + def failure_reason; end + + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/apply_workspace_edit_result.rb#50 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyClientCapabilities + # @return [CallHierarchyClientCapabilities] a new instance of CallHierarchyClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_client_capabilities.rb#24 + def attributes; end + + # Whether implementation supports dynamic registration. If this is set to + # `true` the client supports the new `(TextDocumentRegistrationOptions & + # StaticRegistrationOptions)` return value for the corresponding server + # capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_client_capabilities.rb#20 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_client_capabilities.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_client_capabilities.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_call.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyIncomingCall + # @return [CallHierarchyIncomingCall] a new instance of CallHierarchyIncomingCall + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_call.rb#5 + def initialize(from:, from_ranges:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_call.rb#31 + def attributes; end + + # The item that makes the call. + # + # @return [CallHierarchyItem] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_call.rb#18 + def from; end + + # The ranges at which the calls appear. This is relative to the caller + # denoted by [`this.from`](#CallHierarchyIncomingCall.from). + # + # @return [Range[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_call.rb#27 + def from_ranges; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_call.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_call.rb#37 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyIncomingCallsParams + # @return [CallHierarchyIncomingCallsParams] a new instance of CallHierarchyIncomingCallsParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#5 + def initialize(item:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#37 + def attributes; end + + # @return [CallHierarchyItem] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#33 + def item; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#28 + def partial_result_token; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#43 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_incoming_calls_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyItem + # @return [CallHierarchyItem] a new instance of CallHierarchyItem + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#5 + def initialize(name:, kind:, uri:, range:, selection_range:, tags: T.unsafe(nil), detail: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#88 + def attributes; end + + # A data entry field that is preserved between a call hierarchy prepare and + # incoming calls or outgoing calls requests. + # + # @return [unknown] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#84 + def data; end + + # More detail for this item, e.g. the signature of a function. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#48 + def detail; end + + # The kind of this item. + # + # @return [SymbolKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#32 + def kind; end + + # The name of this item. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#24 + def name; end + + # The range enclosing this symbol not including leading/trailing whitespace + # but everything else, e.g. comments and code. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#65 + def range; end + + # The range that should be selected and revealed when this symbol is being + # picked, e.g. the name of a function. Must be contained by the + # [`range`](#CallHierarchyItem.range). + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#75 + def selection_range; end + + # Tags for this item. + # + # @return [1[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#40 + def tags; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#90 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#94 + def to_json(*args); end + + # The resource identifier of this item. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_item.rb#56 + def uri; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_options.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyOptions + # @return [CallHierarchyOptions] a new instance of CallHierarchyOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_call.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyOutgoingCall + # @return [CallHierarchyOutgoingCall] a new instance of CallHierarchyOutgoingCall + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_call.rb#5 + def initialize(to:, from_ranges:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_call.rb#31 + def attributes; end + + # The range at which this item is called. This is the range relative to + # the caller, e.g the item passed to `callHierarchy/outgoingCalls` request. + # + # @return [Range[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_call.rb#27 + def from_ranges; end + + # The item that is called. + # + # @return [CallHierarchyItem] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_call.rb#18 + def to; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_call.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_call.rb#37 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyOutgoingCallsParams + # @return [CallHierarchyOutgoingCallsParams] a new instance of CallHierarchyOutgoingCallsParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#5 + def initialize(item:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#37 + def attributes; end + + # @return [CallHierarchyItem] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#33 + def item; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#28 + def partial_result_token; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#43 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_outgoing_calls_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyPrepareParams + # @return [CallHierarchyPrepareParams] a new instance of CallHierarchyPrepareParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#39 + def attributes; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#27 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#19 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#45 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_prepare_params.rb#35 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#4 +class LanguageServer::Protocol::Interface::CallHierarchyRegistrationOptions + # @return [CallHierarchyRegistrationOptions] a new instance of CallHierarchyRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#20 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/call_hierarchy_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/cancel_params.rb#4 +class LanguageServer::Protocol::Interface::CancelParams + # @return [CancelParams] a new instance of CancelParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/cancel_params.rb#5 + def initialize(id:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/cancel_params.rb#21 + def attributes; end + + # The request id to cancel. + # + # @return [string | number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/cancel_params.rb#17 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/cancel_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/cancel_params.rb#27 + def to_json(*args); end +end + +# Additional information that describes document changes. +# +# source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#7 +class LanguageServer::Protocol::Interface::ChangeAnnotation + # @return [ChangeAnnotation] a new instance of ChangeAnnotation + # + # source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#8 + def initialize(label:, needs_confirmation: T.unsafe(nil), description: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#45 + def attributes; end + + # A human-readable string which is rendered less prominent in + # the user interface. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#41 + def description; end + + # A human-readable string describing the actual change. The string + # is rendered prominent in the user interface. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#23 + def label; end + + # A flag which indicates that user confirmation is needed + # before applying the change. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#32 + def needs_confirmation; end + + # source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#47 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/change_annotation.rb#51 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::ClientCapabilities + # @return [ClientCapabilities] a new instance of ClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#5 + def initialize(workspace: T.unsafe(nil), text_document: T.unsafe(nil), notebook_document: T.unsafe(nil), window: T.unsafe(nil), general: T.unsafe(nil), experimental: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#66 + def attributes; end + + # Experimental client capabilities. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#62 + def experimental; end + + # General client capabilities. + # + # @return [{ staleRequestSupport?: { cancel: boolean; retryOnContentModified: string[]; }; regularExpressions?: RegularExpressionsClientCapabilities; markdown?: any; positionEncodings?: string[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#54 + def general; end + + # Capabilities specific to the notebook document support. + # + # @return [NotebookDocumentClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#38 + def notebook_document; end + + # Text document specific client capabilities. + # + # @return [TextDocumentClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#30 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#68 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#72 + def to_json(*args); end + + # Window specific client capabilities. + # + # @return [{ workDoneProgress?: boolean; showMessage?: ShowMessageRequestClientCapabilities; showDocument?: ShowDocumentClientCapabilities; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#46 + def window; end + + # Workspace specific client capabilities. + # + # @return [{ applyEdit?: boolean; workspaceEdit?: WorkspaceEditClientCapabilities; didChangeConfiguration?: DidChangeConfigurationClientCapabilities; ... 10 more ...; diagnostics?: DiagnosticWorkspaceClientCapabilities; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/client_capabilities.rb#22 + def workspace; end +end + +# A code action represents a change that can be performed in code, e.g. to fix +# a problem or to refactor code. +# +# A CodeAction must set either `edit` and/or a `command`. If both are supplied, +# the `edit` is applied first, then the `command` is executed. +# +# source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#11 +class LanguageServer::Protocol::Interface::CodeAction + # @return [CodeAction] a new instance of CodeAction + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#12 + def initialize(title:, kind: T.unsafe(nil), diagnostics: T.unsafe(nil), is_preferred: T.unsafe(nil), disabled: T.unsafe(nil), edit: T.unsafe(nil), command: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#115 + def attributes; end + + # A command this code action executes. If a code action + # provides an edit and a command, first the edit is + # executed and then the command. + # + # @return [Command] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#102 + def command; end + + # A data entry field that is preserved on a code action between + # a `textDocument/codeAction` and a `codeAction/resolve` request. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#111 + def data; end + + # The diagnostics that this code action resolves. + # + # @return [Diagnostic[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#49 + def diagnostics; end + + # Marks that the code action cannot currently be applied. + # + # Clients should follow the following guidelines regarding disabled code + # actions: + # + # - Disabled code actions are not shown in automatic lightbulbs code + # action menus. + # + # - Disabled actions are shown as faded out in the code action menu when + # the user request a more specific type of code action, such as + # refactorings. + # + # - If the user has a keybinding that auto applies a code action and only + # a disabled code actions are returned, the client should show the user + # an error message with `reason` in the editor. + # + # @return [{ reason: string; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#84 + def disabled; end + + # The workspace edit this code action performs. + # + # @return [WorkspaceEdit] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#92 + def edit; end + + # Marks this as a preferred action. Preferred actions are used by the + # `auto fix` command and can be targeted by keybindings. + # + # A quick fix should be marked preferred if it properly addresses the + # underlying error. A refactoring should be marked preferred if it is the + # most reasonable choice of actions to take. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#62 + def is_preferred; end + + # The kind of the code action. + # + # Used to filter code actions. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#41 + def kind; end + + # A short, human-readable, title for this code action. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#31 + def title; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#117 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action.rb#121 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::CodeActionClientCapabilities + # @return [CodeActionClientCapabilities] a new instance of CodeActionClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), code_action_literal_support: T.unsafe(nil), is_preferred_support: T.unsafe(nil), disabled_support: T.unsafe(nil), data_support: T.unsafe(nil), resolve_support: T.unsafe(nil), honors_change_annotations: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#83 + def attributes; end + + # The client supports code action literals as a valid + # response of the `textDocument/codeAction` request. + # + # @return [{ codeActionKind: { valueSet: string[]; }; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#32 + def code_action_literal_support; end + + # Whether code action supports the `data` property which is + # preserved between a `textDocument/codeAction` and a + # `codeAction/resolve` request. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#58 + def data_support; end + + # Whether code action supports the `disabled` property. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#48 + def disabled_support; end + + # Whether code action supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#23 + def dynamic_registration; end + + # Whether the client honors the change annotations in + # text edits and resource operations returned via the + # `CodeAction#edit` property by for example presenting + # the workspace edit in the user interface and asking + # for confirmation. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#79 + def honors_change_annotations; end + + # Whether code action supports the `isPreferred` property. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#40 + def is_preferred_support; end + + # Whether the client supports resolving additional code action + # properties via a separate `codeAction/resolve` request. + # + # @return [{ properties: string[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#67 + def resolve_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#85 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_client_capabilities.rb#89 + def to_json(*args); end +end + +# Contains additional diagnostic information about the context in which +# a code action is run. +# +# source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#8 +class LanguageServer::Protocol::Interface::CodeActionContext + # @return [CodeActionContext] a new instance of CodeActionContext + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#9 + def initialize(diagnostics:, only: T.unsafe(nil), trigger_kind: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#51 + def attributes; end + + # An array of diagnostics known on the client side overlapping the range + # provided to the `textDocument/codeAction` request. They are provided so + # that the server knows which errors are currently presented to the user + # for the given range. There is no guarantee that these accurately reflect + # the error state of the resource. The primary parameter + # to compute code actions is the provided range. + # + # @return [Diagnostic[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#28 + def diagnostics; end + + # Requested kind of actions to return. + # + # Actions not of this kind are filtered out by the client before being + # shown. So servers can omit computing them. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#39 + def only; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#53 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#57 + def to_json(*args); end + + # The reason why code actions were requested. + # + # @return [CodeActionTriggerKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_context.rb#47 + def trigger_kind; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#4 +class LanguageServer::Protocol::Interface::CodeActionOptions + # @return [CodeActionOptions] a new instance of CodeActionOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), code_action_kinds: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#40 + def attributes; end + + # CodeActionKinds that this server may return. + # + # The list of kinds may be generic, such as `CodeActionKind.Refactor`, + # or the server may list out every specific kind they provide. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#27 + def code_action_kinds; end + + # The server provides support to resolve additional + # information for a code action. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#36 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#46 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_options.rb#16 + def work_done_progress; end +end + +# Params for the CodeActionRequest +# +# source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#7 +class LanguageServer::Protocol::Interface::CodeActionParams + # @return [CodeActionParams] a new instance of CodeActionParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#8 + def initialize(text_document:, range:, context:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#61 + def attributes; end + + # Context carrying additional information. + # + # @return [CodeActionContext] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#57 + def context; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#33 + def partial_result_token; end + + # The range for which the command was invoked. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#49 + def range; end + + # The document in which the command was invoked. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#41 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#63 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#67 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_params.rb#24 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#4 +class LanguageServer::Protocol::Interface::CodeActionRegistrationOptions + # @return [CodeActionRegistrationOptions] a new instance of CodeActionRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), code_action_kinds: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#50 + def attributes; end + + # CodeActionKinds that this server may return. + # + # The list of kinds may be generic, such as `CodeActionKind.Refactor`, + # or the server may list out every specific kind they provide. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#37 + def code_action_kinds; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#21 + def document_selector; end + + # The server provides support to resolve additional + # information for a code action. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#46 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#52 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#56 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_action_registration_options.rb#26 + def work_done_progress; end +end + +# Structure to capture a description for an error code. +# +# source://language_server-protocol//lib/language_server/protocol/interface/code_description.rb#7 +class LanguageServer::Protocol::Interface::CodeDescription + # @return [CodeDescription] a new instance of CodeDescription + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_description.rb#8 + def initialize(href:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_description.rb#24 + def attributes; end + + # An URI to open with more information about the diagnostic error. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_description.rb#20 + def href; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_description.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_description.rb#30 + def to_json(*args); end +end + +# A code lens represents a command that should be shown along with +# source text, like the number of references, a way to run tests, etc. +# +# A code lens is _unresolved_ when no command is associated to it. For +# performance reasons the creation of a code lens and resolving should be done +# in two stages. +# +# source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#12 +class LanguageServer::Protocol::Interface::CodeLens + # @return [CodeLens] a new instance of CodeLens + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#13 + def initialize(range:, command: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#49 + def attributes; end + + # The command this code lens represents. + # + # @return [Command] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#36 + def command; end + + # A data entry field that is preserved on a code lens item between + # a code lens and a code lens resolve request. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#45 + def data; end + + # The range in which this code lens is valid. Should only span a single + # line. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#28 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens.rb#55 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_lens_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::CodeLensClientCapabilities + # @return [CodeLensClientCapabilities] a new instance of CodeLensClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_client_capabilities.rb#21 + def attributes; end + + # Whether code lens supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_lens_options.rb#4 +class LanguageServer::Protocol::Interface::CodeLensOptions + # @return [CodeLensOptions] a new instance of CodeLensOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_options.rb#27 + def attributes; end + + # Code lens has a resolve provider as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_options.rb#23 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_options.rb#29 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_options.rb#33 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_options.rb#15 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#4 +class LanguageServer::Protocol::Interface::CodeLensParams + # @return [CodeLensParams] a new instance of CodeLensParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#5 + def initialize(text_document:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#40 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#28 + def partial_result_token; end + + # The document to request code lens for. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#36 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#46 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#4 +class LanguageServer::Protocol::Interface::CodeLensRegistrationOptions + # @return [CodeLensRegistrationOptions] a new instance of CodeLensRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#37 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#20 + def document_selector; end + + # Code lens has a resolve provider as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#33 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#43 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/code_lens_workspace_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::CodeLensWorkspaceClientCapabilities + # @return [CodeLensWorkspaceClientCapabilities] a new instance of CodeLensWorkspaceClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_workspace_client_capabilities.rb#5 + def initialize(refresh_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_workspace_client_capabilities.rb#27 + def attributes; end + + # Whether the client implementation supports a refresh request sent from the + # server to the client. + # + # Note that this event is global and will force the client to refresh all + # code lenses currently shown. It should be used with absolute care and is + # useful for situation where a server for example detect a project wide + # change that requires such a calculation. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_workspace_client_capabilities.rb#23 + def refresh_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_workspace_client_capabilities.rb#29 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/code_lens_workspace_client_capabilities.rb#33 + def to_json(*args); end +end + +# Represents a color in RGBA space. +# +# source://language_server-protocol//lib/language_server/protocol/interface/color.rb#7 +class LanguageServer::Protocol::Interface::Color + # @return [Color] a new instance of Color + # + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#8 + def initialize(red:, green:, blue:, alpha:); end + + # The alpha component of this color in the range [0-1]. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#47 + def alpha; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#51 + def attributes; end + + # The blue component of this color in the range [0-1]. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#39 + def blue; end + + # The green component of this color in the range [0-1]. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#31 + def green; end + + # The red component of this color in the range [0-1]. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#23 + def red; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#53 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color.rb#57 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/color_information.rb#4 +class LanguageServer::Protocol::Interface::ColorInformation + # @return [ColorInformation] a new instance of ColorInformation + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_information.rb#5 + def initialize(range:, color:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_information.rb#30 + def attributes; end + + # The actual color value for this color range. + # + # @return [Color] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_information.rb#26 + def color; end + + # The range in the document where this color appears. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_information.rb#18 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color_information.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color_information.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#4 +class LanguageServer::Protocol::Interface::ColorPresentation + # @return [ColorPresentation] a new instance of ColorPresentation + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#5 + def initialize(label:, text_edit: T.unsafe(nil), additional_text_edits: T.unsafe(nil)); end + + # An optional array of additional [text edits](#TextEdit) that are applied + # when selecting this color presentation. Edits must not overlap with the + # main [edit](#ColorPresentation.textEdit) nor with themselves. + # + # @return [TextEdit[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#41 + def additional_text_edits; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#45 + def attributes; end + + # The label of this color presentation. It will be shown on the color + # picker header. By default this is also the text that is inserted when + # selecting this color presentation. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#21 + def label; end + + # An [edit](#TextEdit) which is applied to a document when selecting + # this presentation for the color. When `falsy` the + # [label](#ColorPresentation.label) is used. + # + # @return [TextEdit] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#31 + def text_edit; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#47 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation.rb#51 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#4 +class LanguageServer::Protocol::Interface::ColorPresentationParams + # @return [ColorPresentationParams] a new instance of ColorPresentationParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#5 + def initialize(text_document:, color:, range:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#58 + def attributes; end + + # The color information to request presentations for. + # + # @return [Color] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#46 + def color; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#30 + def partial_result_token; end + + # The range where the color would be inserted. Serves as a context. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#54 + def range; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#38 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#60 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#64 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/color_presentation_params.rb#21 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/command.rb#4 +class LanguageServer::Protocol::Interface::Command + # @return [Command] a new instance of Command + # + # source://language_server-protocol//lib/language_server/protocol/interface/command.rb#5 + def initialize(title:, command:, arguments: T.unsafe(nil)); end + + # Arguments that the command handler should be + # invoked with. + # + # @return [LSPAny[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/command.rb#36 + def arguments; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/command.rb#40 + def attributes; end + + # The identifier of the actual command handler. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/command.rb#27 + def command; end + + # Title of the command, like `save`. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/command.rb#19 + def title; end + + # source://language_server-protocol//lib/language_server/protocol/interface/command.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/command.rb#46 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::CompletionClientCapabilities + # @return [CompletionClientCapabilities] a new instance of CompletionClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), completion_item: T.unsafe(nil), completion_item_kind: T.unsafe(nil), context_support: T.unsafe(nil), insert_text_mode: T.unsafe(nil), completion_list: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#67 + def attributes; end + + # The client supports the following `CompletionItem` specific + # capabilities. + # + # @return [{ snippetSupport?: boolean; commitCharactersSupport?: boolean; documentationFormat?: MarkupKind[]; deprecatedSupport?: boolean; preselectSupport?: boolean; tagSupport?: { valueSet: 1[]; }; insertReplaceSupport?: boolean; resolveSupport?: { ...; }; insertTextModeSupport?: { ...; }; labelDetailsSupport?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#31 + def completion_item; end + + # @return [{ valueSet?: CompletionItemKind[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#36 + def completion_item_kind; end + + # The client supports the following `CompletionList` specific + # capabilities. + # + # @return [{ itemDefaults?: string[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#63 + def completion_list; end + + # The client supports to send additional context information for a + # `textDocument/completion` request. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#45 + def context_support; end + + # Whether completion supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#22 + def dynamic_registration; end + + # The client's default when the completion item doesn't provide a + # `insertTextMode` property. + # + # @return [InsertTextMode] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#54 + def insert_text_mode; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#69 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_client_capabilities.rb#73 + def to_json(*args); end +end + +# Contains additional information about the context in which a completion +# request is triggered. +# +# source://language_server-protocol//lib/language_server/protocol/interface/completion_context.rb#8 +class LanguageServer::Protocol::Interface::CompletionContext + # @return [CompletionContext] a new instance of CompletionContext + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_context.rb#9 + def initialize(trigger_kind:, trigger_character: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_context.rb#36 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_context.rb#38 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_context.rb#42 + def to_json(*args); end + + # The trigger character (a single character) that has trigger code + # complete. Is undefined if + # `triggerKind !== CompletionTriggerKind.TriggerCharacter` + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_context.rb#32 + def trigger_character; end + + # How the completion was triggered. + # + # @return [CompletionTriggerKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_context.rb#22 + def trigger_kind; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#4 +class LanguageServer::Protocol::Interface::CompletionItem + # @return [CompletionItem] a new instance of CompletionItem + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#5 + def initialize(label:, label_details: T.unsafe(nil), kind: T.unsafe(nil), tags: T.unsafe(nil), detail: T.unsafe(nil), documentation: T.unsafe(nil), deprecated: T.unsafe(nil), preselect: T.unsafe(nil), sort_text: T.unsafe(nil), filter_text: T.unsafe(nil), insert_text: T.unsafe(nil), insert_text_format: T.unsafe(nil), insert_text_mode: T.unsafe(nil), text_edit: T.unsafe(nil), text_edit_text: T.unsafe(nil), additional_text_edits: T.unsafe(nil), commit_characters: T.unsafe(nil), command: T.unsafe(nil), data: T.unsafe(nil)); end + + # An optional array of additional text edits that are applied when + # selecting this completion. Edits must not overlap (including the same + # insert position) with the main edit nor with themselves. + # + # Additional text edits should be used to change text unrelated to the + # current cursor position (for example adding an import statement at the + # top of the file if the completion item will insert an unqualified type). + # + # @return [TextEdit[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#221 + def additional_text_edits; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#255 + def attributes; end + + # An optional command that is executed *after* inserting this completion. + # *Note* that additional modifications to the current document should be + # described with the additionalTextEdits-property. + # + # @return [Command] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#242 + def command; end + + # An optional set of characters that when pressed while this completion is + # active will accept it first and then type that character. *Note* that all + # commit characters should have `length=1` and that superfluous characters + # will be ignored. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#232 + def commit_characters; end + + # A data entry field that is preserved on a completion item between + # a completion and a completion resolve request. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#251 + def data; end + + # Indicates if this item is deprecated. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#92 + def deprecated; end + + # A human-readable string with additional information + # about this item, like type or symbol information. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#76 + def detail; end + + # A human-readable string that represents a doc-comment. + # + # @return [string | MarkupContent] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#84 + def documentation; end + + # A string that should be used when filtering a set of + # completion items. When `falsy` the label is used as the + # filter text for this item. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#124 + def filter_text; end + + # A string that should be inserted into a document when selecting + # this completion. When `falsy` the label is used as the insert text + # for this item. + # + # The `insertText` is subject to interpretation by the client side. + # Some tools might not take the string literally. For example + # VS Code when code complete is requested in this example + # `con` and a completion item with an `insertText` of + # `console` is provided it will only insert `sole`. Therefore it is + # recommended to use `textEdit` instead since it avoids additional client + # side interpretation. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#142 + def insert_text; end + + # The format of the insert text. The format applies to both the + # `insertText` property and the `newText` property of a provided + # `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`. + # + # Please note that the insertTextFormat doesn't apply to + # `additionalTextEdits`. + # + # @return [InsertTextFormat] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#155 + def insert_text_format; end + + # How whitespace and indentation is handled during completion + # item insertion. If not provided the client's default value depends on + # the `textDocument.completion.insertTextMode` client capability. + # + # @return [InsertTextMode] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#165 + def insert_text_mode; end + + # The kind of this completion item. Based of the kind + # an icon is chosen by the editor. The standardized set + # of available values is defined in `CompletionItemKind`. + # + # @return [CompletionItemKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#59 + def kind; end + + # The label of this completion item. + # + # The label property is also by default the text that + # is inserted when selecting this completion. + # + # If label details are provided the label itself should + # be an unqualified name of the completion item. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#41 + def label; end + + # Additional details for the label + # + # @return [CompletionItemLabelDetails] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#49 + def label_details; end + + # Select this item when showing. + # + # *Note* that only one completion item can be selected and that the + # tool / client decides which item that is. The rule is that the *first* + # item of those that match best is selected. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#104 + def preselect; end + + # A string that should be used when comparing this item + # with other items. When `falsy` the label is used + # as the sort text for this item. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#114 + def sort_text; end + + # Tags for this completion item. + # + # @return [1[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#67 + def tags; end + + # An edit which is applied to a document when selecting this completion. + # When an edit is provided the value of `insertText` is ignored. + # + # *Note:* The range of the edit must be a single line range and it must + # contain the position at which completion has been requested. + # + # Most editors support two different operations when accepting a completion + # item. One is to insert a completion text and the other is to replace an + # existing text with a completion text. Since this can usually not be + # predetermined by a server it can report both ranges. Clients need to + # signal support for `InsertReplaceEdit`s via the + # `textDocument.completion.completionItem.insertReplaceSupport` client + # capability property. + # + # *Note 1:* The text edit's range as well as both ranges from an insert + # replace edit must be a [single line] and they must contain the position + # at which completion has been requested. + # *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range + # must be a prefix of the edit's replace range, that means it must be + # contained and starting at the same position. + # + # @return [TextEdit | InsertReplaceEdit] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#192 + def text_edit; end + + # The edit text used if the completion item is part of a CompletionList and + # CompletionList defines an item default for the text edit range. + # + # Clients will only honor this property if they opt into completion list + # item defaults using the capability `completionList.itemDefaults`. + # + # If not provided and a list's default range is provided the label + # property is used as a text. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#207 + def text_edit_text; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#257 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item.rb#261 + def to_json(*args); end +end + +# Additional details for a completion item label. +# +# source://language_server-protocol//lib/language_server/protocol/interface/completion_item_label_details.rb#7 +class LanguageServer::Protocol::Interface::CompletionItemLabelDetails + # @return [CompletionItemLabelDetails] a new instance of CompletionItemLabelDetails + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item_label_details.rb#8 + def initialize(detail: T.unsafe(nil), description: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item_label_details.rb#37 + def attributes; end + + # An optional string which is rendered less prominently after + # {@link CompletionItemLabelDetails.detail}. Should be used for fully qualified + # names or file path. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item_label_details.rb#33 + def description; end + + # An optional string which is rendered less prominently directly after + # {@link CompletionItem.label label}, without any spacing. Should be + # used for function signatures or type annotations. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item_label_details.rb#23 + def detail; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item_label_details.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_item_label_details.rb#43 + def to_json(*args); end +end + +# Represents a collection of [completion items](#CompletionItem) to be +# presented in the editor. +# +# source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#8 +class LanguageServer::Protocol::Interface::CompletionList + # @return [CompletionList] a new instance of CompletionList + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#9 + def initialize(is_incomplete:, items:, item_defaults: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#57 + def attributes; end + + # This list is not complete. Further typing should result in recomputing + # this list. + # + # Recomputed lists have all their items replaced (not appended) in the + # incomplete completion sessions. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#27 + def is_incomplete; end + + # In many cases the items of an actual completion result share the same + # value for properties like `commitCharacters` or the range of a text + # edit. A completion list can therefore define item defaults which will + # be used if a completion item itself doesn't specify the value. + # + # If a completion list specifies a default value and a completion item + # also specifies a corresponding value the one from the item is used. + # + # Servers are only allowed to return default values if the client + # signals support for this via the `completionList.itemDefaults` + # capability. + # + # @return [{ commitCharacters?: string[]; editRange?: Range | { insert: Range; replace: Range; }; insertTextFormat?: InsertTextFormat; insertTextMode?: InsertTextMode; data?: LSPAny; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#45 + def item_defaults; end + + # The completion items. + # + # @return [CompletionItem[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#53 + def items; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#59 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_list.rb#63 + def to_json(*args); end +end + +# Completion options. +# +# source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#7 +class LanguageServer::Protocol::Interface::CompletionOptions + # @return [CompletionOptions] a new instance of CompletionOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#8 + def initialize(work_done_progress: T.unsafe(nil), trigger_characters: T.unsafe(nil), all_commit_characters: T.unsafe(nil), resolve_provider: T.unsafe(nil), completion_item: T.unsafe(nil)); end + + # The list of all possible characters that commit a completion. This field + # can be used if clients don't support individual commit characters per + # completion item. See client capability + # `completion.completionItem.commitCharactersSupport`. + # + # If a server provides both `allCommitCharacters` and commit characters on + # an individual completion item the ones on the completion item win. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#53 + def all_commit_characters; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#75 + def attributes; end + + # The server supports the following `CompletionItem` specific + # capabilities. + # + # @return [{ labelDetailsSupport?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#71 + def completion_item; end + + # The server provides support to resolve additional + # information for a completion item. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#62 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#77 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#81 + def to_json(*args); end + + # The additional characters, beyond the defaults provided by the client (typically + # [a-zA-Z]), that should automatically trigger a completion request. For example + # `.` in JavaScript represents the beginning of an object property or method and is + # thus a good candidate for triggering a completion request. + # + # Most tools trigger a completion request automatically without explicitly + # requesting it using a keyboard shortcut (e.g. Ctrl+Space). Typically they + # do so when the user starts to type an identifier. For example if the user + # types `c` in a JavaScript file code complete will automatically pop up + # present `console` besides others as a completion item. Characters that + # make up identifiers don't need to be listed here. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#39 + def trigger_characters; end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_options.rb#21 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#4 +class LanguageServer::Protocol::Interface::CompletionParams + # @return [CompletionParams] a new instance of CompletionParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil), context: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#60 + def attributes; end + + # The completion context. This is only available if the client specifies + # to send this using the client capability + # `completion.contextSupport === true` + # + # @return [CompletionContext] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#56 + def context; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#46 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#29 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#21 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#62 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#66 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_params.rb#37 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#4 +class LanguageServer::Protocol::Interface::CompletionRegistrationOptions + # @return [CompletionRegistrationOptions] a new instance of CompletionRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), trigger_characters: T.unsafe(nil), all_commit_characters: T.unsafe(nil), resolve_provider: T.unsafe(nil), completion_item: T.unsafe(nil)); end + + # The list of all possible characters that commit a completion. This field + # can be used if clients don't support individual commit characters per + # completion item. See client capability + # `completion.completionItem.commitCharactersSupport`. + # + # If a server provides both `allCommitCharacters` and commit characters on + # an individual completion item the ones on the completion item win. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#60 + def all_commit_characters; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#82 + def attributes; end + + # The server supports the following `CompletionItem` specific + # capabilities. + # + # @return [{ labelDetailsSupport?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#78 + def completion_item; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#23 + def document_selector; end + + # The server provides support to resolve additional + # information for a completion item. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#69 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#84 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#88 + def to_json(*args); end + + # The additional characters, beyond the defaults provided by the client (typically + # [a-zA-Z]), that should automatically trigger a completion request. For example + # `.` in JavaScript represents the beginning of an object property or method and is + # thus a good candidate for triggering a completion request. + # + # Most tools trigger a completion request automatically without explicitly + # requesting it using a keyboard shortcut (e.g. Ctrl+Space). Typically they + # do so when the user starts to type an identifier. For example if the user + # types `c` in a JavaScript file code complete will automatically pop up + # present `console` besides others as a completion item. Characters that + # make up identifiers don't need to be listed here. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#46 + def trigger_characters; end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/completion_registration_options.rb#28 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/configuration_item.rb#4 +class LanguageServer::Protocol::Interface::ConfigurationItem + # @return [ConfigurationItem] a new instance of ConfigurationItem + # + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_item.rb#5 + def initialize(scope_uri: T.unsafe(nil), section: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_item.rb#30 + def attributes; end + + # The scope to get the configuration section for. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_item.rb#18 + def scope_uri; end + + # The configuration section asked for. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_item.rb#26 + def section; end + + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_item.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_item.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/configuration_params.rb#4 +class LanguageServer::Protocol::Interface::ConfigurationParams + # @return [ConfigurationParams] a new instance of ConfigurationParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_params.rb#5 + def initialize(items:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_params.rb#18 + def attributes; end + + # @return [ConfigurationItem[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_params.rb#14 + def items; end + + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_params.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/configuration_params.rb#24 + def to_json(*args); end +end + +# Create file operation +# +# source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#7 +class LanguageServer::Protocol::Interface::CreateFile + # @return [CreateFile] a new instance of CreateFile + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#8 + def initialize(kind:, uri:, options: T.unsafe(nil), annotation_id: T.unsafe(nil)); end + + # An optional annotation identifier describing the operation. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#47 + def annotation_id; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#51 + def attributes; end + + # A create + # + # @return ["create"] + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#23 + def kind; end + + # Additional options + # + # @return [CreateFileOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#39 + def options; end + + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#53 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#57 + def to_json(*args); end + + # The resource to create. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file.rb#31 + def uri; end +end + +# Options to create a file. +# +# source://language_server-protocol//lib/language_server/protocol/interface/create_file_options.rb#7 +class LanguageServer::Protocol::Interface::CreateFileOptions + # @return [CreateFileOptions] a new instance of CreateFileOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file_options.rb#8 + def initialize(overwrite: T.unsafe(nil), ignore_if_exists: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file_options.rb#33 + def attributes; end + + # Ignore if exists. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file_options.rb#29 + def ignore_if_exists; end + + # Overwrite existing file. Overwrite wins over `ignoreIfExists` + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_file_options.rb#21 + def overwrite; end + + # source://language_server-protocol//lib/language_server/protocol/interface/create_file_options.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/create_file_options.rb#39 + def to_json(*args); end +end + +# The parameters sent in notifications/requests for user-initiated creation +# of files. +# +# source://language_server-protocol//lib/language_server/protocol/interface/create_files_params.rb#8 +class LanguageServer::Protocol::Interface::CreateFilesParams + # @return [CreateFilesParams] a new instance of CreateFilesParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_files_params.rb#9 + def initialize(files:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_files_params.rb#25 + def attributes; end + + # An array of all files/folders created in this operation. + # + # @return [FileCreate[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/create_files_params.rb#21 + def files; end + + # source://language_server-protocol//lib/language_server/protocol/interface/create_files_params.rb#27 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/create_files_params.rb#31 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/declaration_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DeclarationClientCapabilities + # @return [DeclarationClientCapabilities] a new instance of DeclarationClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), link_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_client_capabilities.rb#32 + def attributes; end + + # Whether declaration supports dynamic registration. If this is set to + # `true` the client supports the new `DeclarationRegistrationOptions` + # return value for the corresponding server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_client_capabilities.rb#20 + def dynamic_registration; end + + # The client supports additional metadata in the form of declaration links. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_client_capabilities.rb#28 + def link_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_client_capabilities.rb#34 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_client_capabilities.rb#38 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/declaration_options.rb#4 +class LanguageServer::Protocol::Interface::DeclarationOptions + # @return [DeclarationOptions] a new instance of DeclarationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#4 +class LanguageServer::Protocol::Interface::DeclarationParams + # @return [DeclarationParams] a new instance of DeclarationParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#45 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DeclarationRegistrationOptions + # @return [DeclarationRegistrationOptions] a new instance of DeclarationRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#25 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/declaration_registration_options.rb#16 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/definition_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DefinitionClientCapabilities + # @return [DefinitionClientCapabilities] a new instance of DefinitionClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), link_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_client_capabilities.rb#30 + def attributes; end + + # Whether definition supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_client_capabilities.rb#18 + def dynamic_registration; end + + # The client supports additional metadata in the form of definition links. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_client_capabilities.rb#26 + def link_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_client_capabilities.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_client_capabilities.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/definition_options.rb#4 +class LanguageServer::Protocol::Interface::DefinitionOptions + # @return [DefinitionOptions] a new instance of DefinitionOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#4 +class LanguageServer::Protocol::Interface::DefinitionParams + # @return [DefinitionParams] a new instance of DefinitionParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#45 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/definition_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DefinitionRegistrationOptions + # @return [DefinitionRegistrationOptions] a new instance of DefinitionRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_registration_options.rb#28 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_registration_options.rb#19 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/definition_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/definition_registration_options.rb#24 + def work_done_progress; end +end + +# Delete file operation +# +# source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#7 +class LanguageServer::Protocol::Interface::DeleteFile + # @return [DeleteFile] a new instance of DeleteFile + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#8 + def initialize(kind:, uri:, options: T.unsafe(nil), annotation_id: T.unsafe(nil)); end + + # An optional annotation identifier describing the operation. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#47 + def annotation_id; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#51 + def attributes; end + + # A delete + # + # @return ["delete"] + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#23 + def kind; end + + # Delete options. + # + # @return [DeleteFileOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#39 + def options; end + + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#53 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#57 + def to_json(*args); end + + # The file to delete. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file.rb#31 + def uri; end +end + +# Delete file options +# +# source://language_server-protocol//lib/language_server/protocol/interface/delete_file_options.rb#7 +class LanguageServer::Protocol::Interface::DeleteFileOptions + # @return [DeleteFileOptions] a new instance of DeleteFileOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file_options.rb#8 + def initialize(recursive: T.unsafe(nil), ignore_if_not_exists: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file_options.rb#33 + def attributes; end + + # Ignore the operation if the file doesn't exist. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file_options.rb#29 + def ignore_if_not_exists; end + + # Delete the content recursively if a folder is denoted. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file_options.rb#21 + def recursive; end + + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file_options.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/delete_file_options.rb#39 + def to_json(*args); end +end + +# The parameters sent in notifications/requests for user-initiated deletes +# of files. +# +# source://language_server-protocol//lib/language_server/protocol/interface/delete_files_params.rb#8 +class LanguageServer::Protocol::Interface::DeleteFilesParams + # @return [DeleteFilesParams] a new instance of DeleteFilesParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_files_params.rb#9 + def initialize(files:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_files_params.rb#25 + def attributes; end + + # An array of all files/folders deleted in this operation. + # + # @return [FileDelete[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/delete_files_params.rb#21 + def files; end + + # source://language_server-protocol//lib/language_server/protocol/interface/delete_files_params.rb#27 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/delete_files_params.rb#31 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#4 +class LanguageServer::Protocol::Interface::Diagnostic + # @return [Diagnostic] a new instance of Diagnostic + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#5 + def initialize(range:, message:, severity: T.unsafe(nil), code: T.unsafe(nil), code_description: T.unsafe(nil), source: T.unsafe(nil), tags: T.unsafe(nil), related_information: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#98 + def attributes; end + + # The diagnostic's code, which might appear in the user interface. + # + # @return [string | number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#42 + def code; end + + # An optional property to describe the error code. + # + # @return [CodeDescription] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#50 + def code_description; end + + # A data entry field that is preserved between a + # `textDocument/publishDiagnostics` notification and + # `textDocument/codeAction` request. + # + # @return [unknown] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#94 + def data; end + + # The diagnostic's message. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#67 + def message; end + + # The range at which the message applies. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#25 + def range; end + + # An array of related diagnostic information, e.g. when symbol-names within + # a scope collide all definitions can be marked via this property. + # + # @return [DiagnosticRelatedInformation[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#84 + def related_information; end + + # The diagnostic's severity. Can be omitted. If omitted it is up to the + # client to interpret diagnostics as error, warning, info or hint. + # + # @return [DiagnosticSeverity] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#34 + def severity; end + + # A human-readable string describing the source of this + # diagnostic, e.g. 'typescript' or 'super lint'. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#59 + def source; end + + # Additional metadata about the diagnostic. + # + # @return [DiagnosticTag[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#75 + def tags; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#100 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic.rb#104 + def to_json(*args); end +end + +# Client capabilities specific to diagnostic pull requests. +# +# source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::DiagnosticClientCapabilities + # @return [DiagnosticClientCapabilities] a new instance of DiagnosticClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_client_capabilities.rb#8 + def initialize(dynamic_registration: T.unsafe(nil), related_document_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_client_capabilities.rb#37 + def attributes; end + + # Whether implementation supports dynamic registration. If this is set to + # `true` the client supports the new + # `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + # return value for the corresponding server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_client_capabilities.rb#24 + def dynamic_registration; end + + # Whether the clients supports related documents for document diagnostic + # pulls. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_client_capabilities.rb#33 + def related_document_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_client_capabilities.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_client_capabilities.rb#43 + def to_json(*args); end +end + +# Diagnostic options. +# +# source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#7 +class LanguageServer::Protocol::Interface::DiagnosticOptions + # @return [DiagnosticOptions] a new instance of DiagnosticOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#8 + def initialize(inter_file_dependencies:, workspace_diagnostics:, work_done_progress: T.unsafe(nil), identifier: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#52 + def attributes; end + + # An optional identifier under which the diagnostics are + # managed by the client. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#29 + def identifier; end + + # Whether the language has inter file dependencies meaning that + # editing code in one file can result in a different diagnostic + # set in another file. Inter file dependencies are common for + # most programming languages and typically uncommon for linters. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#40 + def inter_file_dependencies; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#54 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#58 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#20 + def work_done_progress; end + + # The server provides support for workspace diagnostics as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_options.rb#48 + def workspace_diagnostics; end +end + +# Diagnostic registration options. +# +# source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#7 +class LanguageServer::Protocol::Interface::DiagnosticRegistrationOptions + # @return [DiagnosticRegistrationOptions] a new instance of DiagnosticRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#8 + def initialize(document_selector:, inter_file_dependencies:, workspace_diagnostics:, work_done_progress: T.unsafe(nil), identifier: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#72 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#26 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#68 + def id; end + + # An optional identifier under which the diagnostics are + # managed by the client. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#40 + def identifier; end + + # Whether the language has inter file dependencies meaning that + # editing code in one file can result in a different diagnostic + # set in another file. Inter file dependencies are common for + # most programming languages and typically uncommon for linters. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#51 + def inter_file_dependencies; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#74 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#78 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#31 + def work_done_progress; end + + # The server provides support for workspace diagnostics as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_registration_options.rb#59 + def workspace_diagnostics; end +end + +# Represents a related message and source code location for a diagnostic. +# This should be used to point to code locations that cause or are related to +# a diagnostics, e.g when duplicating a symbol in a scope. +# +# source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_related_information.rb#9 +class LanguageServer::Protocol::Interface::DiagnosticRelatedInformation + # @return [DiagnosticRelatedInformation] a new instance of DiagnosticRelatedInformation + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_related_information.rb#10 + def initialize(location:, message:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_related_information.rb#35 + def attributes; end + + # The location of this related diagnostic information. + # + # @return [Location] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_related_information.rb#23 + def location; end + + # The message of this related diagnostic information. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_related_information.rb#31 + def message; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_related_information.rb#37 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_related_information.rb#41 + def to_json(*args); end +end + +# Cancellation data returned from a diagnostic request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_server_cancellation_data.rb#7 +class LanguageServer::Protocol::Interface::DiagnosticServerCancellationData + # @return [DiagnosticServerCancellationData] a new instance of DiagnosticServerCancellationData + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_server_cancellation_data.rb#8 + def initialize(retrigger_request:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_server_cancellation_data.rb#21 + def attributes; end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_server_cancellation_data.rb#17 + def retrigger_request; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_server_cancellation_data.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_server_cancellation_data.rb#27 + def to_json(*args); end +end + +# Workspace client capabilities specific to diagnostic pull requests. +# +# source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_workspace_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::DiagnosticWorkspaceClientCapabilities + # @return [DiagnosticWorkspaceClientCapabilities] a new instance of DiagnosticWorkspaceClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_workspace_client_capabilities.rb#8 + def initialize(refresh_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_workspace_client_capabilities.rb#30 + def attributes; end + + # Whether the client implementation supports a refresh request sent from + # the server to the client. + # + # Note that this event is global and will force the client to refresh all + # pulled diagnostics currently shown. It should be used with absolute care + # and is useful for situation where a server for example detects a project + # wide change that requires such a calculation. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_workspace_client_capabilities.rb#26 + def refresh_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_workspace_client_capabilities.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/diagnostic_workspace_client_capabilities.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DidChangeConfigurationClientCapabilities + # @return [DidChangeConfigurationClientCapabilities] a new instance of DidChangeConfigurationClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_client_capabilities.rb#21 + def attributes; end + + # Did change configuration notification supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_params.rb#4 +class LanguageServer::Protocol::Interface::DidChangeConfigurationParams + # @return [DidChangeConfigurationParams] a new instance of DidChangeConfigurationParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_params.rb#5 + def initialize(settings:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_params.rb#21 + def attributes; end + + # The actual changed settings + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_params.rb#17 + def settings; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_configuration_params.rb#27 + def to_json(*args); end +end + +# The params sent in a change notebook document notification. +# +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_notebook_document_params.rb#7 +class LanguageServer::Protocol::Interface::DidChangeNotebookDocumentParams + # @return [DidChangeNotebookDocumentParams] a new instance of DidChangeNotebookDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_notebook_document_params.rb#8 + def initialize(notebook_document:, change:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_notebook_document_params.rb#44 + def attributes; end + + # The actual changes to the notebook document. + # + # The change describes single state change to the notebook document. + # So it moves a notebook document, its cells and its cell text document + # contents from state S to S'. + # + # To mirror the content of a notebook using change events use the + # following approach: + # - start with the same initial content + # - apply the 'notebookDocument/didChange' notifications in the order + # you receive them. + # + # @return [NotebookDocumentChangeEvent] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_notebook_document_params.rb#40 + def change; end + + # The notebook document that did change. The version number points + # to the version after all provided changes have been applied. + # + # @return [VersionedNotebookDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_notebook_document_params.rb#22 + def notebook_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_notebook_document_params.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_notebook_document_params.rb#50 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_text_document_params.rb#4 +class LanguageServer::Protocol::Interface::DidChangeTextDocumentParams + # @return [DidChangeTextDocumentParams] a new instance of DidChangeTextDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_text_document_params.rb#5 + def initialize(text_document:, content_changes:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_text_document_params.rb#44 + def attributes; end + + # The actual content changes. The content changes describe single state + # changes to the document. So if there are two content changes c1 (at + # array index 0) and c2 (at array index 1) for a document in state S then + # c1 moves the document from S to S' and c2 from S' to S''. So c1 is + # computed on the state S and c2 is computed on the state S'. + # + # To mirror the content of a document using change events use the following + # approach: + # - start with the same initial content + # - apply the 'textDocument/didChange' notifications in the order you + # receive them. + # - apply the `TextDocumentContentChangeEvent`s in a single notification + # in the order you receive them. + # + # @return [TextDocumentContentChangeEvent[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_text_document_params.rb#40 + def content_changes; end + + # The document that did change. The version number points + # to the version after all provided content changes have + # been applied. + # + # @return [VersionedTextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_text_document_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_text_document_params.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_text_document_params.rb#50 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DidChangeWatchedFilesClientCapabilities + # @return [DidChangeWatchedFilesClientCapabilities] a new instance of DidChangeWatchedFilesClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), relative_pattern_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_client_capabilities.rb#33 + def attributes; end + + # Did change watched files notification supports dynamic registration. + # Please note that the current protocol doesn't support static + # configuration for file changes from the server side. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_client_capabilities.rb#20 + def dynamic_registration; end + + # Whether the client has support for relative patterns + # or not. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_client_capabilities.rb#29 + def relative_pattern_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_client_capabilities.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_client_capabilities.rb#39 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_params.rb#4 +class LanguageServer::Protocol::Interface::DidChangeWatchedFilesParams + # @return [DidChangeWatchedFilesParams] a new instance of DidChangeWatchedFilesParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_params.rb#5 + def initialize(changes:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_params.rb#21 + def attributes; end + + # The actual file events. + # + # @return [FileEvent[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_params.rb#17 + def changes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_params.rb#27 + def to_json(*args); end +end + +# Describe options to be used when registering for file system change events. +# +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_registration_options.rb#7 +class LanguageServer::Protocol::Interface::DidChangeWatchedFilesRegistrationOptions + # @return [DidChangeWatchedFilesRegistrationOptions] a new instance of DidChangeWatchedFilesRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_registration_options.rb#8 + def initialize(watchers:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_registration_options.rb#24 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_registration_options.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_registration_options.rb#30 + def to_json(*args); end + + # The watchers to register. + # + # @return [FileSystemWatcher[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_watched_files_registration_options.rb#20 + def watchers; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_change_workspace_folders_params.rb#4 +class LanguageServer::Protocol::Interface::DidChangeWorkspaceFoldersParams + # @return [DidChangeWorkspaceFoldersParams] a new instance of DidChangeWorkspaceFoldersParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_workspace_folders_params.rb#5 + def initialize(event:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_workspace_folders_params.rb#21 + def attributes; end + + # The actual workspace folder change event. + # + # @return [WorkspaceFoldersChangeEvent] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_workspace_folders_params.rb#17 + def event; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_workspace_folders_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_change_workspace_folders_params.rb#27 + def to_json(*args); end +end + +# The params sent in a close notebook document notification. +# +# source://language_server-protocol//lib/language_server/protocol/interface/did_close_notebook_document_params.rb#7 +class LanguageServer::Protocol::Interface::DidCloseNotebookDocumentParams + # @return [DidCloseNotebookDocumentParams] a new instance of DidCloseNotebookDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_notebook_document_params.rb#8 + def initialize(notebook_document:, cell_text_documents:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_notebook_document_params.rb#34 + def attributes; end + + # The text documents that represent the content + # of a notebook cell that got closed. + # + # @return [TextDocumentIdentifier[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_notebook_document_params.rb#30 + def cell_text_documents; end + + # The notebook document that got closed. + # + # @return [NotebookDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_notebook_document_params.rb#21 + def notebook_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_notebook_document_params.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_notebook_document_params.rb#40 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_close_text_document_params.rb#4 +class LanguageServer::Protocol::Interface::DidCloseTextDocumentParams + # @return [DidCloseTextDocumentParams] a new instance of DidCloseTextDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_text_document_params.rb#5 + def initialize(text_document:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_text_document_params.rb#21 + def attributes; end + + # The document that was closed. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_text_document_params.rb#17 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_text_document_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_close_text_document_params.rb#27 + def to_json(*args); end +end + +# The params sent in an open notebook document notification. +# +# source://language_server-protocol//lib/language_server/protocol/interface/did_open_notebook_document_params.rb#7 +class LanguageServer::Protocol::Interface::DidOpenNotebookDocumentParams + # @return [DidOpenNotebookDocumentParams] a new instance of DidOpenNotebookDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_notebook_document_params.rb#8 + def initialize(notebook_document:, cell_text_documents:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_notebook_document_params.rb#34 + def attributes; end + + # The text documents that represent the content + # of a notebook cell. + # + # @return [TextDocumentItem[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_notebook_document_params.rb#30 + def cell_text_documents; end + + # The notebook document that got opened. + # + # @return [NotebookDocument] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_notebook_document_params.rb#21 + def notebook_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_notebook_document_params.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_notebook_document_params.rb#40 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_open_text_document_params.rb#4 +class LanguageServer::Protocol::Interface::DidOpenTextDocumentParams + # @return [DidOpenTextDocumentParams] a new instance of DidOpenTextDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_text_document_params.rb#5 + def initialize(text_document:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_text_document_params.rb#21 + def attributes; end + + # The document that was opened. + # + # @return [TextDocumentItem] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_text_document_params.rb#17 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_text_document_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_open_text_document_params.rb#27 + def to_json(*args); end +end + +# The params sent in a save notebook document notification. +# +# source://language_server-protocol//lib/language_server/protocol/interface/did_save_notebook_document_params.rb#7 +class LanguageServer::Protocol::Interface::DidSaveNotebookDocumentParams + # @return [DidSaveNotebookDocumentParams] a new instance of DidSaveNotebookDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_notebook_document_params.rb#8 + def initialize(notebook_document:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_notebook_document_params.rb#24 + def attributes; end + + # The notebook document that got saved. + # + # @return [NotebookDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_notebook_document_params.rb#20 + def notebook_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_notebook_document_params.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_notebook_document_params.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/did_save_text_document_params.rb#4 +class LanguageServer::Protocol::Interface::DidSaveTextDocumentParams + # @return [DidSaveTextDocumentParams] a new instance of DidSaveTextDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_text_document_params.rb#5 + def initialize(text_document:, text: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_text_document_params.rb#31 + def attributes; end + + # Optional the content when saved. Depends on the includeText value + # when the save notification was requested. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_text_document_params.rb#27 + def text; end + + # The document that was saved. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_text_document_params.rb#18 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_text_document_params.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/did_save_text_document_params.rb#37 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_color_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DocumentColorClientCapabilities + # @return [DocumentColorClientCapabilities] a new instance of DocumentColorClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_client_capabilities.rb#21 + def attributes; end + + # Whether document color supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_color_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentColorOptions + # @return [DocumentColorOptions] a new instance of DocumentColorOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#4 +class LanguageServer::Protocol::Interface::DocumentColorParams + # @return [DocumentColorParams] a new instance of DocumentColorParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#5 + def initialize(text_document:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#40 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#28 + def partial_result_token; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#36 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#46 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentColorRegistrationOptions + # @return [DocumentColorRegistrationOptions] a new instance of DocumentColorRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#5 + def initialize(document_selector:, id: T.unsafe(nil), work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#20 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#29 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_color_registration_options.rb#34 + def work_done_progress; end +end + +# Parameters of the document diagnostic request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#7 +class LanguageServer::Protocol::Interface::DocumentDiagnosticParams + # @return [DocumentDiagnosticParams] a new instance of DocumentDiagnosticParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#8 + def initialize(text_document:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil), identifier: T.unsafe(nil), previous_result_id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#61 + def attributes; end + + # The additional identifier provided during registration. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#49 + def identifier; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#33 + def partial_result_token; end + + # The result id of a previous response if provided. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#57 + def previous_result_id; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#41 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#63 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#67 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_params.rb#24 + def work_done_token; end +end + +# A partial result for a document diagnostic report. +# +# source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_report_partial_result.rb#7 +class LanguageServer::Protocol::Interface::DocumentDiagnosticReportPartialResult + # @return [DocumentDiagnosticReportPartialResult] a new instance of DocumentDiagnosticReportPartialResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_report_partial_result.rb#8 + def initialize(related_documents:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_report_partial_result.rb#21 + def attributes; end + + # @return [{ [uri: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_report_partial_result.rb#17 + def related_documents; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_report_partial_result.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_diagnostic_report_partial_result.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#4 +class LanguageServer::Protocol::Interface::DocumentFilter + # @return [DocumentFilter] a new instance of DocumentFilter + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#5 + def initialize(language: T.unsafe(nil), scheme: T.unsafe(nil), pattern: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#51 + def attributes; end + + # A language id, like `typescript`. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#19 + def language; end + + # A glob pattern, like `*.{ts,js}`. + # + # Glob patterns can have the following syntax: + # - `*` to match one or more characters in a path segment + # - `?` to match on one character in a path segment + # - `**` to match any number of path segments, including none + # - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}` + # matches all TypeScript and JavaScript files) + # - `[]` to declare a range of characters to match in a path segment + # (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) + # - `[!...]` to negate a range of characters to match in a path segment + # (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but + # not `example.0`) + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#47 + def pattern; end + + # A Uri [scheme](#Uri.scheme), like `file` or `untitled`. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#27 + def scheme; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#53 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_filter.rb#57 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DocumentFormattingClientCapabilities + # @return [DocumentFormattingClientCapabilities] a new instance of DocumentFormattingClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_client_capabilities.rb#21 + def attributes; end + + # Whether formatting supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentFormattingOptions + # @return [DocumentFormattingOptions] a new instance of DocumentFormattingOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#4 +class LanguageServer::Protocol::Interface::DocumentFormattingParams + # @return [DocumentFormattingParams] a new instance of DocumentFormattingParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#5 + def initialize(text_document:, options:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#39 + def attributes; end + + # The format options. + # + # @return [FormattingOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#35 + def options; end + + # The document to format. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#27 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#45 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentFormattingRegistrationOptions + # @return [DocumentFormattingRegistrationOptions] a new instance of DocumentFormattingRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_registration_options.rb#28 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_registration_options.rb#19 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_formatting_registration_options.rb#24 + def work_done_progress; end +end + +# A document highlight is a range inside a text document which deserves +# special attention. Usually a document highlight is visualized by changing +# the background color of its range. +# +# source://language_server-protocol//lib/language_server/protocol/interface/document_highlight.rb#9 +class LanguageServer::Protocol::Interface::DocumentHighlight + # @return [DocumentHighlight] a new instance of DocumentHighlight + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight.rb#10 + def initialize(range:, kind: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight.rb#35 + def attributes; end + + # The highlight kind, default is DocumentHighlightKind.Text. + # + # @return [DocumentHighlightKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight.rb#31 + def kind; end + + # The range this highlight applies to. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight.rb#23 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight.rb#37 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight.rb#41 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DocumentHighlightClientCapabilities + # @return [DocumentHighlightClientCapabilities] a new instance of DocumentHighlightClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_client_capabilities.rb#21 + def attributes; end + + # Whether document highlight supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentHighlightOptions + # @return [DocumentHighlightOptions] a new instance of DocumentHighlightOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#4 +class LanguageServer::Protocol::Interface::DocumentHighlightParams + # @return [DocumentHighlightParams] a new instance of DocumentHighlightParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#45 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentHighlightRegistrationOptions + # @return [DocumentHighlightRegistrationOptions] a new instance of DocumentHighlightRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_registration_options.rb#28 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_registration_options.rb#19 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_highlight_registration_options.rb#24 + def work_done_progress; end +end + +# A document link is a range in a text document that links to an internal or +# external resource, like another text document or a web site. +# +# source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#8 +class LanguageServer::Protocol::Interface::DocumentLink + # @return [DocumentLink] a new instance of DocumentLink + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#9 + def initialize(range:, target: T.unsafe(nil), tooltip: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#58 + def attributes; end + + # A data entry field that is preserved on a document link between a + # DocumentLinkRequest and a DocumentLinkResolveRequest. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#54 + def data; end + + # The range this link applies to. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#24 + def range; end + + # The uri this link points to. If missing a resolve request is sent later. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#32 + def target; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#60 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#64 + def to_json(*args); end + + # The tooltip text when you hover over this link. + # + # If a tooltip is provided, is will be displayed in a string that includes + # instructions on how to trigger the link, such as `{0} (ctrl + click)`. + # The specific instructions vary depending on OS, user settings, and + # localization. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link.rb#45 + def tooltip; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_link_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DocumentLinkClientCapabilities + # @return [DocumentLinkClientCapabilities] a new instance of DocumentLinkClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), tooltip_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_client_capabilities.rb#30 + def attributes; end + + # Whether document link supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_client_capabilities.rb#18 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_client_capabilities.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_client_capabilities.rb#36 + def to_json(*args); end + + # Whether the client supports the `tooltip` property on `DocumentLink`. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_client_capabilities.rb#26 + def tooltip_support; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_link_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentLinkOptions + # @return [DocumentLinkOptions] a new instance of DocumentLinkOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_options.rb#27 + def attributes; end + + # Document links have a resolve provider as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_options.rb#23 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_options.rb#29 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_options.rb#33 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_options.rb#15 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#4 +class LanguageServer::Protocol::Interface::DocumentLinkParams + # @return [DocumentLinkParams] a new instance of DocumentLinkParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#5 + def initialize(text_document:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#40 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#28 + def partial_result_token; end + + # The document to provide document links for. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#36 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#46 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentLinkRegistrationOptions + # @return [DocumentLinkRegistrationOptions] a new instance of DocumentLinkRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#37 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#20 + def document_selector; end + + # Document links have a resolve provider as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#33 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#43 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_link_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DocumentOnTypeFormattingClientCapabilities + # @return [DocumentOnTypeFormattingClientCapabilities] a new instance of DocumentOnTypeFormattingClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_client_capabilities.rb#21 + def attributes; end + + # Whether on type formatting supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentOnTypeFormattingOptions + # @return [DocumentOnTypeFormattingOptions] a new instance of DocumentOnTypeFormattingOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_options.rb#5 + def initialize(first_trigger_character:, more_trigger_character: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_options.rb#30 + def attributes; end + + # A character on which formatting should be triggered, like `{`. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_options.rb#18 + def first_trigger_character; end + + # More trigger characters. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_options.rb#26 + def more_trigger_character; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_options.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_options.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#4 +class LanguageServer::Protocol::Interface::DocumentOnTypeFormattingParams + # @return [DocumentOnTypeFormattingParams] a new instance of DocumentOnTypeFormattingParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#5 + def initialize(text_document:, position:, ch:, options:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#53 + def attributes; end + + # The character that has been typed that triggered the formatting + # on type request. That is not necessarily the last character that + # got inserted into the document since the client could auto insert + # characters as well (e.g. like automatic brace completion). + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#41 + def ch; end + + # The formatting options. + # + # @return [FormattingOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#49 + def options; end + + # The position around which the on type formatting should happen. + # This is not necessarily the exact position where the character denoted + # by the property `ch` got typed. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#30 + def position; end + + # The document to format. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#55 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_params.rb#59 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentOnTypeFormattingRegistrationOptions + # @return [DocumentOnTypeFormattingRegistrationOptions] a new instance of DocumentOnTypeFormattingRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#5 + def initialize(document_selector:, first_trigger_character:, more_trigger_character: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#40 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#20 + def document_selector; end + + # A character on which formatting should be triggered, like `{`. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#28 + def first_trigger_character; end + + # More trigger characters. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#36 + def more_trigger_character; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_on_type_formatting_registration_options.rb#46 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DocumentRangeFormattingClientCapabilities + # @return [DocumentRangeFormattingClientCapabilities] a new instance of DocumentRangeFormattingClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_client_capabilities.rb#21 + def attributes; end + + # Whether formatting supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentRangeFormattingOptions + # @return [DocumentRangeFormattingOptions] a new instance of DocumentRangeFormattingOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#4 +class LanguageServer::Protocol::Interface::DocumentRangeFormattingParams + # @return [DocumentRangeFormattingParams] a new instance of DocumentRangeFormattingParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#5 + def initialize(text_document:, range:, options:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#48 + def attributes; end + + # The format options + # + # @return [FormattingOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#44 + def options; end + + # The range to format + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#36 + def range; end + + # The document to format. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#28 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#50 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#54 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_params.rb#20 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentRangeFormattingRegistrationOptions + # @return [DocumentRangeFormattingRegistrationOptions] a new instance of DocumentRangeFormattingRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_registration_options.rb#28 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_registration_options.rb#19 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_range_formatting_registration_options.rb#24 + def work_done_progress; end +end + +# Represents programming constructs like variables, classes, interfaces etc. +# that appear in a document. Document symbols can be hierarchical and they +# have two ranges: one that encloses its definition and one that points to its +# most interesting range, e.g. the range of an identifier. +# +# source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#10 +class LanguageServer::Protocol::Interface::DocumentSymbol + # @return [DocumentSymbol] a new instance of DocumentSymbol + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#11 + def initialize(name:, kind:, range:, selection_range:, detail: T.unsafe(nil), tags: T.unsafe(nil), deprecated: T.unsafe(nil), children: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#96 + def attributes; end + + # Children of this symbol, e.g. properties of a class. + # + # @return [DocumentSymbol[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#92 + def children; end + + # Indicates if this symbol is deprecated. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#64 + def deprecated; end + + # More detail for this symbol, e.g the signature of a function. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#40 + def detail; end + + # The kind of this symbol. + # + # @return [SymbolKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#48 + def kind; end + + # The name of this symbol. Will be displayed in the user interface and + # therefore must not be an empty string or a string only consisting of + # white spaces. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#32 + def name; end + + # The range enclosing this symbol not including leading/trailing whitespace + # but everything else like comments. This information is typically used to + # determine if the clients cursor is inside the symbol to reveal in the + # symbol in the UI. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#75 + def range; end + + # The range that should be selected and revealed when this symbol is being + # picked, e.g. the name of a function. Must be contained by the `range`. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#84 + def selection_range; end + + # Tags for this document symbol. + # + # @return [1[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#56 + def tags; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#98 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol.rb#102 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::DocumentSymbolClientCapabilities + # @return [DocumentSymbolClientCapabilities] a new instance of DocumentSymbolClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), symbol_kind: T.unsafe(nil), hierarchical_document_symbol_support: T.unsafe(nil), tag_support: T.unsafe(nil), label_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#61 + def attributes; end + + # Whether document symbol supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#21 + def dynamic_registration; end + + # The client supports hierarchical document symbols. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#38 + def hierarchical_document_symbol_support; end + + # The client supports an additional label presented in the UI when + # registering a document symbol provider. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#57 + def label_support; end + + # Specific capabilities for the `SymbolKind` in the + # `textDocument/documentSymbol` request. + # + # @return [{ valueSet?: SymbolKind[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#30 + def symbol_kind; end + + # The client supports tags on `SymbolInformation`. Tags are supported on + # `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true. + # Clients supporting tags have to handle unknown tags gracefully. + # + # @return [{ valueSet: 1[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#48 + def tag_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#63 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_client_capabilities.rb#67 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentSymbolOptions + # @return [DocumentSymbolOptions] a new instance of DocumentSymbolOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), label: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_options.rb#28 + def attributes; end + + # A human-readable string that is shown when multiple outlines trees + # are shown for the same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_options.rb#24 + def label; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_options.rb#15 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#4 +class LanguageServer::Protocol::Interface::DocumentSymbolParams + # @return [DocumentSymbolParams] a new instance of DocumentSymbolParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#5 + def initialize(text_document:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#40 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#28 + def partial_result_token; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#36 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#46 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#4 +class LanguageServer::Protocol::Interface::DocumentSymbolRegistrationOptions + # @return [DocumentSymbolRegistrationOptions] a new instance of DocumentSymbolRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), label: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#20 + def document_selector; end + + # A human-readable string that is shown when multiple outlines trees + # are shown for the same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#34 + def label; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/document_symbol_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/execute_command_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::ExecuteCommandClientCapabilities + # @return [ExecuteCommandClientCapabilities] a new instance of ExecuteCommandClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_client_capabilities.rb#21 + def attributes; end + + # Execute command supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/execute_command_options.rb#4 +class LanguageServer::Protocol::Interface::ExecuteCommandOptions + # @return [ExecuteCommandOptions] a new instance of ExecuteCommandOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_options.rb#5 + def initialize(commands:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_options.rb#27 + def attributes; end + + # The commands to be executed on the server + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_options.rb#23 + def commands; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_options.rb#29 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_options.rb#33 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_options.rb#15 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#4 +class LanguageServer::Protocol::Interface::ExecuteCommandParams + # @return [ExecuteCommandParams] a new instance of ExecuteCommandParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#5 + def initialize(command:, work_done_token: T.unsafe(nil), arguments: T.unsafe(nil)); end + + # Arguments that the command should be invoked with. + # + # @return [LSPAny[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#35 + def arguments; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#39 + def attributes; end + + # The identifier of the actual command handler. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#27 + def command; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#45 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_params.rb#19 + def work_done_token; end +end + +# Execute command registration options. +# +# source://language_server-protocol//lib/language_server/protocol/interface/execute_command_registration_options.rb#7 +class LanguageServer::Protocol::Interface::ExecuteCommandRegistrationOptions + # @return [ExecuteCommandRegistrationOptions] a new instance of ExecuteCommandRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_registration_options.rb#8 + def initialize(commands:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_registration_options.rb#30 + def attributes; end + + # The commands to be executed on the server + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_registration_options.rb#26 + def commands; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_registration_options.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_registration_options.rb#36 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execute_command_registration_options.rb#18 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/execution_summary.rb#4 +class LanguageServer::Protocol::Interface::ExecutionSummary + # @return [ExecutionSummary] a new instance of ExecutionSummary + # + # source://language_server-protocol//lib/language_server/protocol/interface/execution_summary.rb#5 + def initialize(execution_order:, success: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/execution_summary.rb#33 + def attributes; end + + # A strict monotonically increasing value + # indicating the execution order of a cell + # inside a notebook. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execution_summary.rb#20 + def execution_order; end + + # Whether the execution was successful or + # not if known by the client. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/execution_summary.rb#29 + def success; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execution_summary.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/execution_summary.rb#39 + def to_json(*args); end +end + +# Represents information on a file/folder create. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_create.rb#7 +class LanguageServer::Protocol::Interface::FileCreate + # @return [FileCreate] a new instance of FileCreate + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_create.rb#8 + def initialize(uri:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_create.rb#24 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_create.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_create.rb#30 + def to_json(*args); end + + # A file:// URI for the location of the file/folder being created. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_create.rb#20 + def uri; end +end + +# Represents information on a file/folder delete. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_delete.rb#7 +class LanguageServer::Protocol::Interface::FileDelete + # @return [FileDelete] a new instance of FileDelete + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_delete.rb#8 + def initialize(uri:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_delete.rb#24 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_delete.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_delete.rb#30 + def to_json(*args); end + + # A file:// URI for the location of the file/folder being deleted. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_delete.rb#20 + def uri; end +end + +# An event describing a file change. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_event.rb#7 +class LanguageServer::Protocol::Interface::FileEvent + # @return [FileEvent] a new instance of FileEvent + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_event.rb#8 + def initialize(uri:, type:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_event.rb#33 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_event.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_event.rb#39 + def to_json(*args); end + + # The change type. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_event.rb#29 + def type; end + + # The file's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_event.rb#21 + def uri; end +end + +# A filter to describe in which file operation requests or notifications +# the server is interested in. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_operation_filter.rb#8 +class LanguageServer::Protocol::Interface::FileOperationFilter + # @return [FileOperationFilter] a new instance of FileOperationFilter + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_filter.rb#9 + def initialize(pattern:, scheme: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_filter.rb#34 + def attributes; end + + # The actual file operation pattern. + # + # @return [FileOperationPattern] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_filter.rb#30 + def pattern; end + + # A Uri like `file` or `untitled`. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_filter.rb#22 + def scheme; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_filter.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_filter.rb#40 + def to_json(*args); end +end + +# A pattern to describe in which file operation requests or notifications +# the server is interested in. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#8 +class LanguageServer::Protocol::Interface::FileOperationPattern + # @return [FileOperationPattern] a new instance of FileOperationPattern + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#9 + def initialize(glob:, matches: T.unsafe(nil), options: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#55 + def attributes; end + + # The glob pattern to match. Glob patterns can have the following syntax: + # - `*` to match one or more characters in a path segment + # - `?` to match on one character in a path segment + # - `**` to match any number of path segments, including none + # - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}` + # matches all TypeScript and JavaScript files) + # - `[]` to declare a range of characters to match in a path segment + # (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) + # - `[!...]` to negate a range of characters to match in a path segment + # (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but + # not `example.0`) + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#33 + def glob; end + + # Whether to match files or folders with this pattern. + # + # Matches both if undefined. + # + # @return [FileOperationPatternKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#43 + def matches; end + + # Additional options used during matching. + # + # @return [FileOperationPatternOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#51 + def options; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#57 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern.rb#61 + def to_json(*args); end +end + +# Matching options for the file operation pattern. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern_options.rb#7 +class LanguageServer::Protocol::Interface::FileOperationPatternOptions + # @return [FileOperationPatternOptions] a new instance of FileOperationPatternOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern_options.rb#8 + def initialize(ignore_case: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern_options.rb#24 + def attributes; end + + # The pattern should be matched ignoring casing. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern_options.rb#20 + def ignore_case; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern_options.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_pattern_options.rb#30 + def to_json(*args); end +end + +# The options to register for file operations. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_operation_registration_options.rb#7 +class LanguageServer::Protocol::Interface::FileOperationRegistrationOptions + # @return [FileOperationRegistrationOptions] a new instance of FileOperationRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_registration_options.rb#8 + def initialize(filters:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_registration_options.rb#24 + def attributes; end + + # The actual filters. + # + # @return [FileOperationFilter[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_registration_options.rb#20 + def filters; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_registration_options.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_operation_registration_options.rb#30 + def to_json(*args); end +end + +# Represents information on a file/folder rename. +# +# source://language_server-protocol//lib/language_server/protocol/interface/file_rename.rb#7 +class LanguageServer::Protocol::Interface::FileRename + # @return [FileRename] a new instance of FileRename + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_rename.rb#8 + def initialize(old_uri:, new_uri:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_rename.rb#33 + def attributes; end + + # A file:// URI for the new location of the file/folder being renamed. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_rename.rb#29 + def new_uri; end + + # A file:// URI for the original location of the file/folder being renamed. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_rename.rb#21 + def old_uri; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_rename.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_rename.rb#39 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/file_system_watcher.rb#4 +class LanguageServer::Protocol::Interface::FileSystemWatcher + # @return [FileSystemWatcher] a new instance of FileSystemWatcher + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_system_watcher.rb#5 + def initialize(glob_pattern:, kind: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_system_watcher.rb#33 + def attributes; end + + # The glob pattern to watch. See {@link GlobPattern glob pattern} + # for more detail. + # + # @return [GlobPattern] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_system_watcher.rb#19 + def glob_pattern; end + + # The kind of events of interest. If omitted it defaults + # to WatchKind.Create | WatchKind.Change | WatchKind.Delete + # which is 7. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/file_system_watcher.rb#29 + def kind; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_system_watcher.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/file_system_watcher.rb#39 + def to_json(*args); end +end + +# Represents a folding range. To be valid, start and end line must be bigger +# than zero and smaller than the number of lines in the document. Clients +# are free to ignore invalid ranges. +# +# source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#9 +class LanguageServer::Protocol::Interface::FoldingRange + # @return [FoldingRange] a new instance of FoldingRange + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#10 + def initialize(start_line:, end_line:, start_character: T.unsafe(nil), end_character: T.unsafe(nil), kind: T.unsafe(nil), collapsed_text: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#82 + def attributes; end + + # The text that the client should show when the specified range is + # collapsed. If not defined or not supported by the client, a default + # will be chosen by the client. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#78 + def collapsed_text; end + + # The zero-based character offset before the folded range ends. If not + # defined, defaults to the length of the end line. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#57 + def end_character; end + + # The zero-based end line of the range to fold. The folded area ends with + # the line's last character. To be valid, the end must be zero or larger + # and smaller than the number of lines in the document. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#48 + def end_line; end + + # Describes the kind of the folding range such as `comment` or `region`. + # The kind is used to categorize folding ranges and used by commands like + # 'Fold all comments'. See [FoldingRangeKind](#FoldingRangeKind) for an + # enumeration of standardized kinds. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#68 + def kind; end + + # The zero-based character offset from where the folded range starts. If + # not defined, defaults to the length of the start line. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#38 + def start_character; end + + # The zero-based start line of the range to fold. The folded area starts + # after the line's last character. To be valid, the end must be zero or + # larger and smaller than the number of lines in the document. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#29 + def start_line; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#84 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range.rb#88 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::FoldingRangeClientCapabilities + # @return [FoldingRangeClientCapabilities] a new instance of FoldingRangeClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), range_limit: T.unsafe(nil), line_folding_only: T.unsafe(nil), folding_range_kind: T.unsafe(nil), folding_range: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#64 + def attributes; end + + # Whether implementation supports dynamic registration for folding range + # providers. If this is set to `true` the client supports the new + # `FoldingRangeRegistrationOptions` return value for the corresponding + # server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#24 + def dynamic_registration; end + + # Specific options for the folding range. + # + # @return [{ collapsedText?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#60 + def folding_range; end + + # Specific options for the folding range kind. + # + # @return [{ valueSet?: string[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#52 + def folding_range_kind; end + + # If set, the client signals that it only supports folding complete lines. + # If set, client will ignore specified `startCharacter` and `endCharacter` + # properties in a FoldingRange. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#44 + def line_folding_only; end + + # The maximum number of folding ranges that the client prefers to receive + # per document. The value serves as a hint, servers are free to follow the + # limit. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#34 + def range_limit; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#66 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_client_capabilities.rb#70 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/folding_range_options.rb#4 +class LanguageServer::Protocol::Interface::FoldingRangeOptions + # @return [FoldingRangeOptions] a new instance of FoldingRangeOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#4 +class LanguageServer::Protocol::Interface::FoldingRangeParams + # @return [FoldingRangeParams] a new instance of FoldingRangeParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#5 + def initialize(text_document:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#40 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#28 + def partial_result_token; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#36 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#46 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#4 +class LanguageServer::Protocol::Interface::FoldingRangeRegistrationOptions + # @return [FoldingRangeRegistrationOptions] a new instance of FoldingRangeRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#20 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/folding_range_registration_options.rb#25 + def work_done_progress; end +end + +# Value-object describing what options formatting should use. +# +# source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#7 +class LanguageServer::Protocol::Interface::FormattingOptions + # @return [FormattingOptions] a new instance of FormattingOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#8 + def initialize(tab_size:, insert_spaces:, trim_trailing_whitespace: T.unsafe(nil), insert_final_newline: T.unsafe(nil), trim_final_newlines: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#60 + def attributes; end + + # Insert a newline character at the end of the file if one does not exist. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#48 + def insert_final_newline; end + + # Prefer spaces over tabs. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#32 + def insert_spaces; end + + # Size of a tab in spaces. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#24 + def tab_size; end + + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#62 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#66 + def to_json(*args); end + + # Trim all newlines after the final newline at the end of the file. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#56 + def trim_final_newlines; end + + # Trim trailing whitespace on a line. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/formatting_options.rb#40 + def trim_trailing_whitespace; end +end + +# A diagnostic report with a full set of problems. +# +# source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#7 +class LanguageServer::Protocol::Interface::FullDocumentDiagnosticReport + # @return [FullDocumentDiagnosticReport] a new instance of FullDocumentDiagnosticReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#8 + def initialize(kind:, items:, result_id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#44 + def attributes; end + + # The actual items. + # + # @return [Diagnostic[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#40 + def items; end + + # A full document diagnostic report. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#22 + def kind; end + + # An optional result id. If provided it will + # be sent on the next diagnostic request for the + # same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#32 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/full_document_diagnostic_report.rb#50 + def to_json(*args); end +end + +# The result of a hover request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/hover.rb#7 +class LanguageServer::Protocol::Interface::Hover + # @return [Hover] a new instance of Hover + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover.rb#8 + def initialize(contents:, range: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover.rb#34 + def attributes; end + + # The hover's content + # + # @return [MarkupContent | MarkedString | MarkedString[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover.rb#21 + def contents; end + + # An optional range is a range inside a text document + # that is used to visualize a hover, e.g. by changing the background color. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover.rb#30 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover.rb#40 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/hover_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::HoverClientCapabilities + # @return [HoverClientCapabilities] a new instance of HoverClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), content_format: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_client_capabilities.rb#32 + def attributes; end + + # Client supports the follow content formats if the content + # property refers to a `literal of type MarkupContent`. + # The order describes the preferred format of the client. + # + # @return [MarkupKind[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_client_capabilities.rb#28 + def content_format; end + + # Whether hover supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_client_capabilities.rb#18 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_client_capabilities.rb#34 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_client_capabilities.rb#38 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/hover_options.rb#4 +class LanguageServer::Protocol::Interface::HoverOptions + # @return [HoverOptions] a new instance of HoverOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#4 +class LanguageServer::Protocol::Interface::HoverParams + # @return [HoverParams] a new instance of HoverParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#39 + def attributes; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#27 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#19 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#45 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_params.rb#35 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/hover_registration_options.rb#4 +class LanguageServer::Protocol::Interface::HoverRegistrationOptions + # @return [HoverRegistrationOptions] a new instance of HoverRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_registration_options.rb#28 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_registration_options.rb#19 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_registration_options.rb#24 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/hover_result.rb#4 +class LanguageServer::Protocol::Interface::HoverResult + # @return [HoverResult] a new instance of HoverResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_result.rb#5 + def initialize(value:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_result.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_result.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/hover_result.rb#24 + def to_json(*args); end + + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/hover_result.rb#14 + def value; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/implementation_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::ImplementationClientCapabilities + # @return [ImplementationClientCapabilities] a new instance of ImplementationClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), link_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_client_capabilities.rb#32 + def attributes; end + + # Whether implementation supports dynamic registration. If this is set to + # `true` the client supports the new `ImplementationRegistrationOptions` + # return value for the corresponding server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_client_capabilities.rb#20 + def dynamic_registration; end + + # The client supports additional metadata in the form of definition links. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_client_capabilities.rb#28 + def link_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_client_capabilities.rb#34 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_client_capabilities.rb#38 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/implementation_options.rb#4 +class LanguageServer::Protocol::Interface::ImplementationOptions + # @return [ImplementationOptions] a new instance of ImplementationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#4 +class LanguageServer::Protocol::Interface::ImplementationParams + # @return [ImplementationParams] a new instance of ImplementationParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#45 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#4 +class LanguageServer::Protocol::Interface::ImplementationRegistrationOptions + # @return [ImplementationRegistrationOptions] a new instance of ImplementationRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#20 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/implementation_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/initialize_error.rb#4 +class LanguageServer::Protocol::Interface::InitializeError + # @return [InitializeError] a new instance of InitializeError + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_error.rb#5 + def initialize(retry:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_error.rb#24 + def attributes; end + + # Indicates whether the client execute the following retry logic: + # (1) show the message provided by the ResponseError to the user + # (2) user selects retry or cancel + # (3) if user selected retry the initialize method is sent again. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_error.rb#20 + def retry; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_error.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_error.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#4 +class LanguageServer::Protocol::Interface::InitializeParams + # @return [InitializeParams] a new instance of InitializeParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#5 + def initialize(process_id:, root_uri:, capabilities:, work_done_token: T.unsafe(nil), client_info: T.unsafe(nil), locale: T.unsafe(nil), root_path: T.unsafe(nil), initialization_options: T.unsafe(nil), trace: T.unsafe(nil), workspace_folders: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#116 + def attributes; end + + # The capabilities provided by the client (editor or tool) + # + # @return [ClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#93 + def capabilities; end + + # Information about the client + # + # @return [{ name: string; version?: string; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#45 + def client_info; end + + # User provided initialization options. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#85 + def initialization_options; end + + # The locale the client is currently showing the user interface + # in. This must not necessarily be the locale of the operating + # system. + # + # Uses IETF language tags as the value's syntax + # (See https://en.wikipedia.org/wiki/IETF_language_tag) + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#58 + def locale; end + + # The process Id of the parent process that started the server. Is null if + # the process has not been started by another process. If the parent + # process is not alive then the server should exit (see exit notification) + # its process. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#37 + def process_id; end + + # The rootPath of the workspace. Is null + # if no folder is open. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#67 + def root_path; end + + # The rootUri of the workspace. Is null if no + # folder is open. If both `rootPath` and `rootUri` are set + # `rootUri` wins. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#77 + def root_uri; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#118 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#122 + def to_json(*args); end + + # The initial trace setting. If omitted trace is disabled ('off'). + # + # @return [TraceValue] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#101 + def trace; end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#26 + def work_done_token; end + + # The workspace folders configured in the client when the server starts. + # This property is only available if the client supports workspace folders. + # It can be `null` if the client supports workspace folders but none are + # configured. + # + # @return [WorkspaceFolder[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_params.rb#112 + def workspace_folders; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/initialize_result.rb#4 +class LanguageServer::Protocol::Interface::InitializeResult + # @return [InitializeResult] a new instance of InitializeResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_result.rb#5 + def initialize(capabilities:, server_info: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_result.rb#30 + def attributes; end + + # The capabilities the language server provides. + # + # @return [ServerCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_result.rb#18 + def capabilities; end + + # Information about the server. + # + # @return [{ name: string; version?: string; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_result.rb#26 + def server_info; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_result.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialize_result.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/initialized_params.rb#4 +class LanguageServer::Protocol::Interface::InitializedParams + # @return [InitializedParams] a new instance of InitializedParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialized_params.rb#5 + def initialize; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/initialized_params.rb#12 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialized_params.rb#14 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/initialized_params.rb#18 + def to_json(*args); end +end + +# Inlay hint information. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#7 +class LanguageServer::Protocol::Interface::InlayHint + # @return [InlayHint] a new instance of InlayHint + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#8 + def initialize(position:, label:, kind: T.unsafe(nil), text_edits: T.unsafe(nil), tooltip: T.unsafe(nil), padding_left: T.unsafe(nil), padding_right: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#110 + def attributes; end + + # A data entry field that is preserved on an inlay hint between + # a `textDocument/inlayHint` and a `inlayHint/resolve` request. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#106 + def data; end + + # The kind of this hint. Can be omitted in which case the client + # should fall back to a reasonable default. + # + # @return [InlayHintKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#47 + def kind; end + + # The label of this hint. A human readable string or an array of + # InlayHintLabelPart label parts. + # + # *Note* that neither the string nor the label part can be empty. + # + # @return [string | InlayHintLabelPart[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#38 + def label; end + + # Render padding before the hint. + # + # Note: Padding should use the editor's background color, not the + # background color of the hint itself. That means padding can be used + # to visually align/separate an inlay hint. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#85 + def padding_left; end + + # Render padding after the hint. + # + # Note: Padding should use the editor's background color, not the + # background color of the hint itself. That means padding can be used + # to visually align/separate an inlay hint. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#97 + def padding_right; end + + # The position of this hint. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#27 + def position; end + + # Optional text edits that are performed when accepting this inlay hint. + # + # *Note* that edits are expected to change the document so that the inlay + # hint (or its nearest variant) is now part of the document and the inlay + # hint itself is now obsolete. + # + # Depending on the client capability `inlayHint.resolveSupport` clients + # might resolve this property late using the resolve request. + # + # @return [TextEdit[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#62 + def text_edits; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#112 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#116 + def to_json(*args); end + + # The tooltip text when you hover over this item. + # + # Depending on the client capability `inlayHint.resolveSupport` clients + # might resolve this property late using the resolve request. + # + # @return [string | MarkupContent] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint.rb#73 + def tooltip; end +end + +# Inlay hint client capabilities. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::InlayHintClientCapabilities + # @return [InlayHintClientCapabilities] a new instance of InlayHintClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_client_capabilities.rb#8 + def initialize(dynamic_registration: T.unsafe(nil), resolve_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_client_capabilities.rb#34 + def attributes; end + + # Whether inlay hints support dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_client_capabilities.rb#21 + def dynamic_registration; end + + # Indicates which properties a client can resolve lazily on an inlay + # hint. + # + # @return [{ properties: string[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_client_capabilities.rb#30 + def resolve_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_client_capabilities.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_client_capabilities.rb#40 + def to_json(*args); end +end + +# An inlay hint label part allows for interactive and composite labels +# of inlay hints. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#8 +class LanguageServer::Protocol::Interface::InlayHintLabelPart + # @return [InlayHintLabelPart] a new instance of InlayHintLabelPart + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#9 + def initialize(value:, tooltip: T.unsafe(nil), location: T.unsafe(nil), command: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#67 + def attributes; end + + # An optional command for this label part. + # + # Depending on the client capability `inlayHint.resolveSupport` clients + # might resolve this property late using the resolve request. + # + # @return [Command] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#63 + def command; end + + # An optional source code location that represents this + # label part. + # + # The editor will use this location for the hover and for code navigation + # features: This part will become a clickable link that resolves to the + # definition of the symbol at the given location (not necessarily the + # location itself), it shows the hover that shows at the given location, + # and it shows a context menu with further code navigation commands. + # + # Depending on the client capability `inlayHint.resolveSupport` clients + # might resolve this property late using the resolve request. + # + # @return [Location] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#52 + def location; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#69 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#73 + def to_json(*args); end + + # The tooltip text when you hover over this label part. Depending on + # the client capability `inlayHint.resolveSupport` clients might resolve + # this property late using the resolve request. + # + # @return [string | MarkupContent] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#34 + def tooltip; end + + # The value of this label part. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_label_part.rb#24 + def value; end +end + +# Inlay hint options used during static registration. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_options.rb#7 +class LanguageServer::Protocol::Interface::InlayHintOptions + # @return [InlayHintOptions] a new instance of InlayHintOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_options.rb#8 + def initialize(work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_options.rb#31 + def attributes; end + + # The server provides support to resolve additional + # information for an inlay hint item. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_options.rb#27 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_options.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_options.rb#37 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_options.rb#18 + def work_done_progress; end +end + +# A parameter literal used in inlay hint requests. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#7 +class LanguageServer::Protocol::Interface::InlayHintParams + # @return [InlayHintParams] a new instance of InlayHintParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#8 + def initialize(text_document:, range:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#42 + def attributes; end + + # The visible document range for which inlay hints should be computed. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#38 + def range; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#30 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#44 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#48 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_params.rb#22 + def work_done_token; end +end + +# Inlay hint options used during static or dynamic registration. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#7 +class LanguageServer::Protocol::Interface::InlayHintRegistrationOptions + # @return [InlayHintRegistrationOptions] a new instance of InlayHintRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#8 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#51 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#38 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#47 + def id; end + + # The server provides support to resolve additional + # information for an inlay hint item. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#29 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#53 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#57 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_registration_options.rb#20 + def work_done_progress; end +end + +# Client workspace capabilities specific to inlay hints. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_workspace_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::InlayHintWorkspaceClientCapabilities + # @return [InlayHintWorkspaceClientCapabilities] a new instance of InlayHintWorkspaceClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_workspace_client_capabilities.rb#8 + def initialize(refresh_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_workspace_client_capabilities.rb#30 + def attributes; end + + # Whether the client implementation supports a refresh request sent from + # the server to the client. + # + # Note that this event is global and will force the client to refresh all + # inlay hints currently shown. It should be used with absolute care and + # is useful for situation where a server for example detects a project wide + # change that requires such a calculation. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_workspace_client_capabilities.rb#26 + def refresh_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_workspace_client_capabilities.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inlay_hint_workspace_client_capabilities.rb#36 + def to_json(*args); end +end + +# Client capabilities specific to inline values. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::InlineValueClientCapabilities + # @return [InlineValueClientCapabilities] a new instance of InlineValueClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_client_capabilities.rb#8 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_client_capabilities.rb#25 + def attributes; end + + # Whether implementation supports dynamic registration for inline + # value providers. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_client_capabilities.rb#21 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_client_capabilities.rb#27 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_client_capabilities.rb#31 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_context.rb#4 +class LanguageServer::Protocol::Interface::InlineValueContext + # @return [InlineValueContext] a new instance of InlineValueContext + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_context.rb#5 + def initialize(frame_id:, stopped_location:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_context.rb#32 + def attributes; end + + # The stack frame (as a DAP Id) where the execution has stopped. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_context.rb#18 + def frame_id; end + + # The document range where execution has stopped. + # Typically the end position of the range denotes the line where the + # inline values are shown. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_context.rb#28 + def stopped_location; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_context.rb#34 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_context.rb#38 + def to_json(*args); end +end + +# Provide an inline value through an expression evaluation. +# +# If only a range is specified, the expression will be extracted from the +# underlying document. +# +# An optional expression can be used to override the extracted expression. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_evaluatable_expression.rb#12 +class LanguageServer::Protocol::Interface::InlineValueEvaluatableExpression + # @return [InlineValueEvaluatableExpression] a new instance of InlineValueEvaluatableExpression + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_evaluatable_expression.rb#13 + def initialize(range:, expression: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_evaluatable_expression.rb#40 + def attributes; end + + # If specified the expression overrides the extracted expression. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_evaluatable_expression.rb#36 + def expression; end + + # The document range for which the inline value applies. + # The range is used to extract the evaluatable expression from the + # underlying document. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_evaluatable_expression.rb#28 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_evaluatable_expression.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_evaluatable_expression.rb#46 + def to_json(*args); end +end + +# Inline value options used during static registration. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_options.rb#7 +class LanguageServer::Protocol::Interface::InlineValueOptions + # @return [InlineValueOptions] a new instance of InlineValueOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_options.rb#8 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_options.rb#21 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_options.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_options.rb#27 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_options.rb#17 + def work_done_progress; end +end + +# A parameter literal used in inline value requests. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#7 +class LanguageServer::Protocol::Interface::InlineValueParams + # @return [InlineValueParams] a new instance of InlineValueParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#8 + def initialize(text_document:, range:, context:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#52 + def attributes; end + + # Additional information about the context in which inline values were + # requested. + # + # @return [InlineValueContext] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#48 + def context; end + + # The document range for which inline values should be computed. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#39 + def range; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#31 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#54 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#58 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_params.rb#23 + def work_done_token; end +end + +# Inline value options used during static or dynamic registration. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#7 +class LanguageServer::Protocol::Interface::InlineValueRegistrationOptions + # @return [InlineValueRegistrationOptions] a new instance of InlineValueRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#8 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#41 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#28 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#37 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#43 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#47 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_registration_options.rb#19 + def work_done_progress; end +end + +# Provide inline value as text. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_text.rb#7 +class LanguageServer::Protocol::Interface::InlineValueText + # @return [InlineValueText] a new instance of InlineValueText + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_text.rb#8 + def initialize(range:, text:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_text.rb#33 + def attributes; end + + # The document range for which the inline value applies. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_text.rb#21 + def range; end + + # The text of the inline value. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_text.rb#29 + def text; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_text.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_text.rb#39 + def to_json(*args); end +end + +# Provide inline value through a variable lookup. +# +# If only a range is specified, the variable name will be extracted from +# the underlying document. +# +# An optional variable name can be used to override the extracted name. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#12 +class LanguageServer::Protocol::Interface::InlineValueVariableLookup + # @return [InlineValueVariableLookup] a new instance of InlineValueVariableLookup + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#13 + def initialize(range:, case_sensitive_lookup:, variable_name: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#49 + def attributes; end + + # How to perform the lookup. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#45 + def case_sensitive_lookup; end + + # The document range for which the inline value applies. + # The range is used to extract the variable name from the underlying + # document. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#29 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#55 + def to_json(*args); end + + # If specified the name of the variable to look up. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_variable_lookup.rb#37 + def variable_name; end +end + +# Client workspace capabilities specific to inline values. +# +# source://language_server-protocol//lib/language_server/protocol/interface/inline_value_workspace_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::InlineValueWorkspaceClientCapabilities + # @return [InlineValueWorkspaceClientCapabilities] a new instance of InlineValueWorkspaceClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_workspace_client_capabilities.rb#8 + def initialize(refresh_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_workspace_client_capabilities.rb#30 + def attributes; end + + # Whether the client implementation supports a refresh request sent from + # the server to the client. + # + # Note that this event is global and will force the client to refresh all + # inline values currently shown. It should be used with absolute care and + # is useful for situation where a server for example detect a project wide + # change that requires such a calculation. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_workspace_client_capabilities.rb#26 + def refresh_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_workspace_client_capabilities.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/inline_value_workspace_client_capabilities.rb#36 + def to_json(*args); end +end + +# A special text edit to provide an insert and a replace operation. +# +# source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#7 +class LanguageServer::Protocol::Interface::InsertReplaceEdit + # @return [InsertReplaceEdit] a new instance of InsertReplaceEdit + # + # source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#8 + def initialize(new_text:, insert:, replace:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#42 + def attributes; end + + # The range if the insert is requested + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#30 + def insert; end + + # The string to be inserted. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#22 + def new_text; end + + # The range if the replace is requested. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#38 + def replace; end + + # source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#44 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/insert_replace_edit.rb#48 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::LinkedEditingRangeClientCapabilities + # @return [LinkedEditingRangeClientCapabilities] a new instance of LinkedEditingRangeClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_client_capabilities.rb#24 + def attributes; end + + # Whether the implementation supports dynamic registration. + # If this is set to `true` the client supports the new + # `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + # return value for the corresponding server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_client_capabilities.rb#20 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_client_capabilities.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_client_capabilities.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_options.rb#4 +class LanguageServer::Protocol::Interface::LinkedEditingRangeOptions + # @return [LinkedEditingRangeOptions] a new instance of LinkedEditingRangeOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#4 +class LanguageServer::Protocol::Interface::LinkedEditingRangeParams + # @return [LinkedEditingRangeParams] a new instance of LinkedEditingRangeParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#39 + def attributes; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#27 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#19 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#45 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_params.rb#35 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#4 +class LanguageServer::Protocol::Interface::LinkedEditingRangeRegistrationOptions + # @return [LinkedEditingRangeRegistrationOptions] a new instance of LinkedEditingRangeRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#20 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_range_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_ranges.rb#4 +class LanguageServer::Protocol::Interface::LinkedEditingRanges + # @return [LinkedEditingRanges] a new instance of LinkedEditingRanges + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_ranges.rb#5 + def initialize(ranges:, word_pattern: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_ranges.rb#34 + def attributes; end + + # A list of ranges that can be renamed together. The ranges must have + # identical length and contain identical text content. The ranges cannot + # overlap. + # + # @return [Range[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_ranges.rb#20 + def ranges; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_ranges.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_ranges.rb#40 + def to_json(*args); end + + # An optional word pattern (regular expression) that describes valid + # contents for the given ranges. If no pattern is provided, the client + # configuration's word pattern will be used. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/linked_editing_ranges.rb#30 + def word_pattern; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/location.rb#4 +class LanguageServer::Protocol::Interface::Location + # @return [Location] a new instance of Location + # + # source://language_server-protocol//lib/language_server/protocol/interface/location.rb#5 + def initialize(uri:, range:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/location.rb#24 + def attributes; end + + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/location.rb#20 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/location.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/location.rb#30 + def to_json(*args); end + + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/location.rb#15 + def uri; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#4 +class LanguageServer::Protocol::Interface::LocationLink + # @return [LocationLink] a new instance of LocationLink + # + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#5 + def initialize(target_uri:, target_range:, target_selection_range:, origin_selection_range: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#56 + def attributes; end + + # Span of the origin of this link. + # + # Used as the underlined span for mouse interaction. Defaults to the word + # range at the mouse position. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#23 + def origin_selection_range; end + + # The full target range of this link. If the target for example is a symbol + # then target range is the range enclosing this symbol not including + # leading/trailing whitespace but everything else like comments. This + # information is typically used to highlight the range in the editor. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#42 + def target_range; end + + # The range that should be selected and revealed when this link is being + # followed, e.g the name of a function. Must be contained by the + # `targetRange`. See also `DocumentSymbol#range` + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#52 + def target_selection_range; end + + # The target resource identifier of this link. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#31 + def target_uri; end + + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#58 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/location_link.rb#62 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/log_message_params.rb#4 +class LanguageServer::Protocol::Interface::LogMessageParams + # @return [LogMessageParams] a new instance of LogMessageParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_message_params.rb#5 + def initialize(type:, message:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_message_params.rb#30 + def attributes; end + + # The actual message + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_message_params.rb#26 + def message; end + + # source://language_server-protocol//lib/language_server/protocol/interface/log_message_params.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/log_message_params.rb#36 + def to_json(*args); end + + # The message type. See {@link MessageType} + # + # @return [MessageType] + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_message_params.rb#18 + def type; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/log_trace_params.rb#4 +class LanguageServer::Protocol::Interface::LogTraceParams + # @return [LogTraceParams] a new instance of LogTraceParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_trace_params.rb#5 + def initialize(message:, verbose: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_trace_params.rb#31 + def attributes; end + + # The message to be logged. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_trace_params.rb#18 + def message; end + + # source://language_server-protocol//lib/language_server/protocol/interface/log_trace_params.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/log_trace_params.rb#37 + def to_json(*args); end + + # Additional information that can be computed if the `trace` configuration + # is set to `'verbose'` + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/log_trace_params.rb#27 + def verbose; end +end + +# A `MarkupContent` literal represents a string value which content is +# interpreted base on its kind flag. Currently the protocol supports +# `plaintext` and `markdown` as markup kinds. +# +# If the kind is `markdown` then the value can contain fenced code blocks like +# in GitHub issues. +# +# Here is an example how such a string can be constructed using +# JavaScript / TypeScript: +# ```typescript +# let markdown: MarkdownContent = { +# kind: MarkupKind.Markdown, +# value: [ +# '# Header', +# 'Some text', +# '```typescript', +# 'someCode();', +# '```' +# ].join('\n') +# }; +# ``` +# +# *Please Note* that clients might sanitize the return markdown. A client could +# decide to remove HTML from the markdown to avoid script execution. +# +# source://language_server-protocol//lib/language_server/protocol/interface/markup_content.rb#30 +class LanguageServer::Protocol::Interface::MarkupContent + # @return [MarkupContent] a new instance of MarkupContent + # + # source://language_server-protocol//lib/language_server/protocol/interface/markup_content.rb#31 + def initialize(kind:, value:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/markup_content.rb#56 + def attributes; end + + # The type of the Markup + # + # @return [MarkupKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/markup_content.rb#44 + def kind; end + + # source://language_server-protocol//lib/language_server/protocol/interface/markup_content.rb#58 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/markup_content.rb#62 + def to_json(*args); end + + # The content itself + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/markup_content.rb#52 + def value; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/message.rb#4 +class LanguageServer::Protocol::Interface::Message + # @return [Message] a new instance of Message + # + # source://language_server-protocol//lib/language_server/protocol/interface/message.rb#5 + def initialize(jsonrpc:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/message.rb#18 + def attributes; end + + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/message.rb#14 + def jsonrpc; end + + # source://language_server-protocol//lib/language_server/protocol/interface/message.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/message.rb#24 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/message_action_item.rb#4 +class LanguageServer::Protocol::Interface::MessageActionItem + # @return [MessageActionItem] a new instance of MessageActionItem + # + # source://language_server-protocol//lib/language_server/protocol/interface/message_action_item.rb#5 + def initialize(title:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/message_action_item.rb#21 + def attributes; end + + # A short title like 'Retry', 'Open Log' etc. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/message_action_item.rb#17 + def title; end + + # source://language_server-protocol//lib/language_server/protocol/interface/message_action_item.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/message_action_item.rb#27 + def to_json(*args); end +end + +# Moniker definition to match LSIF 0.5 moniker definition. +# +# source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#7 +class LanguageServer::Protocol::Interface::Moniker + # @return [Moniker] a new instance of Moniker + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#8 + def initialize(scheme:, identifier:, unique:, kind: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#52 + def attributes; end + + # The identifier of the moniker. The value is opaque in LSIF however + # schema owners are allowed to define the structure if they want. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#32 + def identifier; end + + # The moniker kind if known. + # + # @return [MonikerKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#48 + def kind; end + + # The scheme of the moniker. For example tsc or .Net + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#23 + def scheme; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#54 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#58 + def to_json(*args); end + + # The scope in which the moniker is unique + # + # @return [UniquenessLevel] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker.rb#40 + def unique; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/moniker_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::MonikerClientCapabilities + # @return [MonikerClientCapabilities] a new instance of MonikerClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_client_capabilities.rb#24 + def attributes; end + + # Whether implementation supports dynamic registration. If this is set to + # `true` the client supports the new `(TextDocumentRegistrationOptions & + # StaticRegistrationOptions)` return value for the corresponding server + # capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_client_capabilities.rb#20 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_client_capabilities.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_client_capabilities.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/moniker_options.rb#4 +class LanguageServer::Protocol::Interface::MonikerOptions + # @return [MonikerOptions] a new instance of MonikerOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#4 +class LanguageServer::Protocol::Interface::MonikerParams + # @return [MonikerParams] a new instance of MonikerParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#45 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/moniker_registration_options.rb#4 +class LanguageServer::Protocol::Interface::MonikerRegistrationOptions + # @return [MonikerRegistrationOptions] a new instance of MonikerRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_registration_options.rb#28 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_registration_options.rb#19 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/moniker_registration_options.rb#24 + def work_done_progress; end +end + +# A notebook cell. +# +# A cell's document URI must be unique across ALL notebook +# cells and can therefore be used to uniquely identify a +# notebook cell or the cell's text document. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#11 +class LanguageServer::Protocol::Interface::NotebookCell + # @return [NotebookCell] a new instance of NotebookCell + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#12 + def initialize(kind:, document:, metadata: T.unsafe(nil), execution_summary: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#57 + def attributes; end + + # The URI of the cell's text document + # content. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#36 + def document; end + + # Additional execution summary information + # if supported by the client. + # + # @return [ExecutionSummary] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#53 + def execution_summary; end + + # The cell's kind + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#27 + def kind; end + + # Additional metadata stored with the cell. + # + # @return [LSPObject] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#44 + def metadata; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#59 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell.rb#63 + def to_json(*args); end +end + +# A change describing how to move a `NotebookCell` +# array from state S to S'. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#8 +class LanguageServer::Protocol::Interface::NotebookCellArrayChange + # @return [NotebookCellArrayChange] a new instance of NotebookCellArrayChange + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#9 + def initialize(start:, delete_count:, cells: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#43 + def attributes; end + + # The new cells, if any + # + # @return [NotebookCell[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#39 + def cells; end + + # The deleted cells + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#31 + def delete_count; end + + # The start offset of the cell that changed. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#23 + def start; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#45 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_array_change.rb#49 + def to_json(*args); end +end + +# A notebook cell text document filter denotes a cell text +# document by different properties. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_text_document_filter.rb#8 +class LanguageServer::Protocol::Interface::NotebookCellTextDocumentFilter + # @return [NotebookCellTextDocumentFilter] a new instance of NotebookCellTextDocumentFilter + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_text_document_filter.rb#9 + def initialize(notebook:, language: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_text_document_filter.rb#40 + def attributes; end + + # A language id like `python`. + # + # Will be matched against the language id of the + # notebook cell document. '*' matches every language. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_text_document_filter.rb#36 + def language; end + + # A filter that matches against the notebook + # containing the notebook cell. If a string + # value is provided it matches against the + # notebook type. '*' matches every notebook. + # + # @return [string | NotebookDocumentFilter] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_text_document_filter.rb#25 + def notebook; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_text_document_filter.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_cell_text_document_filter.rb#46 + def to_json(*args); end +end + +# A notebook document. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#7 +class LanguageServer::Protocol::Interface::NotebookDocument + # @return [NotebookDocument] a new instance of NotebookDocument + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#8 + def initialize(uri:, notebook_type:, version:, cells:, metadata: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#62 + def attributes; end + + # The cells of a notebook. + # + # @return [NotebookCell[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#58 + def cells; end + + # Additional metadata stored with the notebook + # document. + # + # @return [LSPObject] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#50 + def metadata; end + + # The type of the notebook. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#32 + def notebook_type; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#64 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#68 + def to_json(*args); end + + # The notebook document's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#24 + def uri; end + + # The version number of this document (it will increase after each + # change, including undo/redo). + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document.rb#41 + def version; end +end + +# A change event for a notebook document. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_change_event.rb#7 +class LanguageServer::Protocol::Interface::NotebookDocumentChangeEvent + # @return [NotebookDocumentChangeEvent] a new instance of NotebookDocumentChangeEvent + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_change_event.rb#8 + def initialize(metadata: T.unsafe(nil), cells: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_change_event.rb#33 + def attributes; end + + # Changes to cells + # + # @return [{ structure?: { array: NotebookCellArrayChange; didOpen?: TextDocumentItem[]; didClose?: TextDocumentIdentifier[]; }; data?: NotebookCell[]; textContent?: { ...; }[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_change_event.rb#29 + def cells; end + + # The changed meta data if any. + # + # @return [LSPObject] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_change_event.rb#21 + def metadata; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_change_event.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_change_event.rb#39 + def to_json(*args); end +end + +# Capabilities specific to the notebook document support. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::NotebookDocumentClientCapabilities + # @return [NotebookDocumentClientCapabilities] a new instance of NotebookDocumentClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_client_capabilities.rb#8 + def initialize(synchronization:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_client_capabilities.rb#24 + def attributes; end + + # Capabilities specific to notebook document synchronization + # + # @return [NotebookDocumentSyncClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_client_capabilities.rb#20 + def synchronization; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_client_capabilities.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_client_capabilities.rb#30 + def to_json(*args); end +end + +# A notebook document filter denotes a notebook document by +# different properties. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#8 +class LanguageServer::Protocol::Interface::NotebookDocumentFilter + # @return [NotebookDocumentFilter] a new instance of NotebookDocumentFilter + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#9 + def initialize(notebook_type: T.unsafe(nil), scheme: T.unsafe(nil), pattern: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#67 + def attributes; end + + # The type of the enclosing notebook. + # + # --- OR --- + # + # The type of the enclosing notebook. + # + # --- OR --- + # + # The type of the enclosing notebook. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#31 + def notebook_type; end + + # A glob pattern. + # + # --- OR --- + # + # A glob pattern. + # + # --- OR --- + # + # A glob pattern. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#63 + def pattern; end + + # A Uri [scheme](#Uri.scheme), like `file` or `untitled`. + # + # --- OR --- + # + # A Uri [scheme](#Uri.scheme), like `file` or `untitled`. + # + # --- OR --- + # + # A Uri [scheme](#Uri.scheme), like `file` or `untitled`. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#47 + def scheme; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#69 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_filter.rb#73 + def to_json(*args); end +end + +# A literal to identify a notebook document in the client. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_identifier.rb#7 +class LanguageServer::Protocol::Interface::NotebookDocumentIdentifier + # @return [NotebookDocumentIdentifier] a new instance of NotebookDocumentIdentifier + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_identifier.rb#8 + def initialize(uri:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_identifier.rb#24 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_identifier.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_identifier.rb#30 + def to_json(*args); end + + # The notebook document's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_identifier.rb#20 + def uri; end +end + +# Notebook specific client capabilities. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::NotebookDocumentSyncClientCapabilities + # @return [NotebookDocumentSyncClientCapabilities] a new instance of NotebookDocumentSyncClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_client_capabilities.rb#8 + def initialize(dynamic_registration: T.unsafe(nil), execution_summary_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_client_capabilities.rb#36 + def attributes; end + + # Whether implementation supports dynamic registration. If this is + # set to `true` the client supports the new + # `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + # return value for the corresponding server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_client_capabilities.rb#24 + def dynamic_registration; end + + # The client supports sending execution summary data per cell. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_client_capabilities.rb#32 + def execution_summary_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_client_capabilities.rb#38 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_client_capabilities.rb#42 + def to_json(*args); end +end + +# Options specific to a notebook plus its cells +# to be synced to the server. +# +# If a selector provides a notebook document +# filter but no cell selector all cells of a +# matching notebook document will be synced. +# +# If a selector provides no notebook document +# filter but only a cell selector all notebook +# documents that contain at least one matching +# cell will be synced. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_options.rb#17 +class LanguageServer::Protocol::Interface::NotebookDocumentSyncOptions + # @return [NotebookDocumentSyncOptions] a new instance of NotebookDocumentSyncOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_options.rb#18 + def initialize(notebook_selector:, save: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_options.rb#44 + def attributes; end + + # The notebooks to be synced + # + # @return [({ notebook: string | NotebookDocumentFilter; cells?: { language: string; }[]; } | { notebook?: string | NotebookDocumentFilter; cells: { ...; }[]; })[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_options.rb#31 + def notebook_selector; end + + # Whether save notification should be forwarded to + # the server. Will only be honored if mode === `notebook`. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_options.rb#40 + def save; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_options.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_options.rb#50 + def to_json(*args); end +end + +# Registration options specific to a notebook. +# +# source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#7 +class LanguageServer::Protocol::Interface::NotebookDocumentSyncRegistrationOptions + # @return [NotebookDocumentSyncRegistrationOptions] a new instance of NotebookDocumentSyncRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#8 + def initialize(notebook_selector:, save: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#44 + def attributes; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#40 + def id; end + + # The notebooks to be synced + # + # @return [({ notebook: string | NotebookDocumentFilter; cells?: { language: string; }[]; } | { notebook?: string | NotebookDocumentFilter; cells: { ...; }[]; })[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#22 + def notebook_selector; end + + # Whether save notification should be forwarded to + # the server. Will only be honored if mode === `notebook`. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#31 + def save; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notebook_document_sync_registration_options.rb#50 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#4 +class LanguageServer::Protocol::Interface::NotificationMessage + # @return [NotificationMessage] a new instance of NotificationMessage + # + # source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#5 + def initialize(jsonrpc:, method:, params: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#36 + def attributes; end + + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#16 + def jsonrpc; end + + # The method to be invoked. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#24 + def method; end + + # The notification's params. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#32 + def params; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#38 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/notification_message.rb#42 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/optional_versioned_text_document_identifier.rb#4 +class LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier + # @return [OptionalVersionedTextDocumentIdentifier] a new instance of OptionalVersionedTextDocumentIdentifier + # + # source://language_server-protocol//lib/language_server/protocol/interface/optional_versioned_text_document_identifier.rb#5 + def initialize(uri:, version:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/optional_versioned_text_document_identifier.rb#38 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/optional_versioned_text_document_identifier.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/optional_versioned_text_document_identifier.rb#44 + def to_json(*args); end + + # The text document's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/optional_versioned_text_document_identifier.rb#18 + def uri; end + + # The version number of this document. If an optional versioned text document + # identifier is sent from the server to the client and the file is not + # open in the editor (the server has not received an open notification + # before) the server can send `null` to indicate that the version is + # known and the content on disk is the master (as specified with document + # content ownership). + # + # The version number of a document will increase after each change, + # including undo/redo. The number doesn't need to be consecutive. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/optional_versioned_text_document_identifier.rb#34 + def version; end +end + +# Represents a parameter of a callable-signature. A parameter can +# have a label and a doc-comment. +# +# source://language_server-protocol//lib/language_server/protocol/interface/parameter_information.rb#8 +class LanguageServer::Protocol::Interface::ParameterInformation + # @return [ParameterInformation] a new instance of ParameterInformation + # + # source://language_server-protocol//lib/language_server/protocol/interface/parameter_information.rb#9 + def initialize(label:, documentation: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/parameter_information.rb#44 + def attributes; end + + # The human-readable doc-comment of this parameter. Will be shown + # in the UI but can be omitted. + # + # @return [string | MarkupContent] + # + # source://language_server-protocol//lib/language_server/protocol/interface/parameter_information.rb#40 + def documentation; end + + # The label of this parameter information. + # + # Either a string or an inclusive start and exclusive end offsets within + # its containing signature label. (see SignatureInformation.label). The + # offsets are based on a UTF-16 string representation as `Position` and + # `Range` does. + # + # *Note*: a label of type string should be a substring of its containing + # signature label. Its intended use case is to highlight the parameter + # label part in the `SignatureInformation.label`. + # + # @return [string | [number, number]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/parameter_information.rb#31 + def label; end + + # source://language_server-protocol//lib/language_server/protocol/interface/parameter_information.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/parameter_information.rb#50 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/partial_result_params.rb#4 +class LanguageServer::Protocol::Interface::PartialResultParams + # @return [PartialResultParams] a new instance of PartialResultParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/partial_result_params.rb#5 + def initialize(partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/partial_result_params.rb#22 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/partial_result_params.rb#18 + def partial_result_token; end + + # source://language_server-protocol//lib/language_server/protocol/interface/partial_result_params.rb#24 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/partial_result_params.rb#28 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/position.rb#4 +class LanguageServer::Protocol::Interface::Position + # @return [Position] a new instance of Position + # + # source://language_server-protocol//lib/language_server/protocol/interface/position.rb#5 + def initialize(line:, character:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/position.rb#34 + def attributes; end + + # Character offset on a line in a document (zero-based). The meaning of this + # offset is determined by the negotiated `PositionEncodingKind`. + # + # If the character value is greater than the line length it defaults back + # to the line length. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/position.rb#30 + def character; end + + # Line position in a document (zero-based). + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/position.rb#18 + def line; end + + # source://language_server-protocol//lib/language_server/protocol/interface/position.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/position.rb#40 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#4 +class LanguageServer::Protocol::Interface::PrepareRenameParams + # @return [PrepareRenameParams] a new instance of PrepareRenameParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#39 + def attributes; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#27 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#19 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#45 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/prepare_rename_params.rb#35 + def work_done_token; end +end + +# A previous result id in a workspace pull request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/previous_result_id.rb#7 +class LanguageServer::Protocol::Interface::PreviousResultId + # @return [PreviousResultId] a new instance of PreviousResultId + # + # source://language_server-protocol//lib/language_server/protocol/interface/previous_result_id.rb#8 + def initialize(uri:, value:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/previous_result_id.rb#34 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/previous_result_id.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/previous_result_id.rb#40 + def to_json(*args); end + + # The URI for which the client knows a + # result id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/previous_result_id.rb#22 + def uri; end + + # The value of the previous result id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/previous_result_id.rb#30 + def value; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/progress_params.rb#4 +class LanguageServer::Protocol::Interface::ProgressParams + # @return [ProgressParams] a new instance of ProgressParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/progress_params.rb#5 + def initialize(token:, value:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/progress_params.rb#30 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/progress_params.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/progress_params.rb#36 + def to_json(*args); end + + # The progress token provided by the client or server. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/progress_params.rb#18 + def token; end + + # The progress data. + # + # @return [T] + # + # source://language_server-protocol//lib/language_server/protocol/interface/progress_params.rb#26 + def value; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::PublishDiagnosticsClientCapabilities + # @return [PublishDiagnosticsClientCapabilities] a new instance of PublishDiagnosticsClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#5 + def initialize(related_information: T.unsafe(nil), tag_support: T.unsafe(nil), version_support: T.unsafe(nil), code_description_support: T.unsafe(nil), data_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#61 + def attributes; end + + # Client supports a codeDescription property + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#47 + def code_description_support; end + + # Whether code action supports the `data` property which is + # preserved between a `textDocument/publishDiagnostics` and + # `textDocument/codeAction` request. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#57 + def data_support; end + + # Whether the clients accepts diagnostics with related information. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#21 + def related_information; end + + # Client supports the tag property to provide meta data about a diagnostic. + # Clients supporting tags have to handle unknown tags gracefully. + # + # @return [{ valueSet: DiagnosticTag[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#30 + def tag_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#63 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#67 + def to_json(*args); end + + # Whether the client interprets the version property of the + # `textDocument/publishDiagnostics` notification's parameter. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_client_capabilities.rb#39 + def version_support; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#4 +class LanguageServer::Protocol::Interface::PublishDiagnosticsParams + # @return [PublishDiagnosticsParams] a new instance of PublishDiagnosticsParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#5 + def initialize(uri:, diagnostics:, version: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#40 + def attributes; end + + # An array of diagnostic information items. + # + # @return [Diagnostic[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#36 + def diagnostics; end + + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#46 + def to_json(*args); end + + # The URI for which diagnostic information is reported. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#19 + def uri; end + + # Optional the version number of the document the diagnostics are published + # for. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/publish_diagnostics_params.rb#28 + def version; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/range.rb#4 +class LanguageServer::Protocol::Interface::Range + # @return [Range] a new instance of Range + # + # source://language_server-protocol//lib/language_server/protocol/interface/range.rb#5 + def initialize(start:, end:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/range.rb#30 + def attributes; end + + # The range's end position. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/range.rb#26 + def end; end + + # The range's start position. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/range.rb#18 + def start; end + + # source://language_server-protocol//lib/language_server/protocol/interface/range.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/range.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/reference_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::ReferenceClientCapabilities + # @return [ReferenceClientCapabilities] a new instance of ReferenceClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_client_capabilities.rb#21 + def attributes; end + + # Whether references supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_client_capabilities.rb#17 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_client_capabilities.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_client_capabilities.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/reference_context.rb#4 +class LanguageServer::Protocol::Interface::ReferenceContext + # @return [ReferenceContext] a new instance of ReferenceContext + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_context.rb#5 + def initialize(include_declaration:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_context.rb#21 + def attributes; end + + # Include the declaration of the current symbol. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_context.rb#17 + def include_declaration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_context.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_context.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/reference_options.rb#4 +class LanguageServer::Protocol::Interface::ReferenceOptions + # @return [ReferenceOptions] a new instance of ReferenceOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#4 +class LanguageServer::Protocol::Interface::ReferenceParams + # @return [ReferenceParams] a new instance of ReferenceParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#5 + def initialize(text_document:, position:, context:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#55 + def attributes; end + + # @return [ReferenceContext] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#51 + def context; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#46 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#29 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#21 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#57 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#61 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_params.rb#37 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/reference_registration_options.rb#4 +class LanguageServer::Protocol::Interface::ReferenceRegistrationOptions + # @return [ReferenceRegistrationOptions] a new instance of ReferenceRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_registration_options.rb#28 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_registration_options.rb#19 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/reference_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/reference_registration_options.rb#24 + def work_done_progress; end +end + +# General parameters to register for a capability. +# +# source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#7 +class LanguageServer::Protocol::Interface::Registration + # @return [Registration] a new instance of Registration + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#8 + def initialize(id:, method:, register_options: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#43 + def attributes; end + + # The id used to register the request. The id can be used to deregister + # the request again. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#23 + def id; end + + # The method / capability to register for. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#31 + def method; end + + # Options necessary for the registration. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#39 + def register_options; end + + # source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#45 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/registration.rb#49 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/registration_params.rb#4 +class LanguageServer::Protocol::Interface::RegistrationParams + # @return [RegistrationParams] a new instance of RegistrationParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration_params.rb#5 + def initialize(registrations:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration_params.rb#18 + def attributes; end + + # @return [Registration[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/registration_params.rb#14 + def registrations; end + + # source://language_server-protocol//lib/language_server/protocol/interface/registration_params.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/registration_params.rb#24 + def to_json(*args); end +end + +# Client capabilities specific to regular expressions. +# +# source://language_server-protocol//lib/language_server/protocol/interface/regular_expressions_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::RegularExpressionsClientCapabilities + # @return [RegularExpressionsClientCapabilities] a new instance of RegularExpressionsClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/regular_expressions_client_capabilities.rb#8 + def initialize(engine:, version: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/regular_expressions_client_capabilities.rb#33 + def attributes; end + + # The engine's name. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/regular_expressions_client_capabilities.rb#21 + def engine; end + + # source://language_server-protocol//lib/language_server/protocol/interface/regular_expressions_client_capabilities.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/regular_expressions_client_capabilities.rb#39 + def to_json(*args); end + + # The engine's version. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/regular_expressions_client_capabilities.rb#29 + def version; end +end + +# A full diagnostic report with a set of related documents. +# +# source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#7 +class LanguageServer::Protocol::Interface::RelatedFullDocumentDiagnosticReport + # @return [RelatedFullDocumentDiagnosticReport] a new instance of RelatedFullDocumentDiagnosticReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#8 + def initialize(kind:, items:, result_id: T.unsafe(nil), related_documents: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#57 + def attributes; end + + # The actual items. + # + # @return [Diagnostic[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#41 + def items; end + + # A full document diagnostic report. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#23 + def kind; end + + # Diagnostics of related documents. This information is useful + # in programming languages where code in a file A can generate + # diagnostics in a file B which A depends on. An example of + # such a language is C/C++ where marco definitions in a file + # a.cpp and result in errors in a header file b.hpp. + # + # @return [{ [uri: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#53 + def related_documents; end + + # An optional result id. If provided it will + # be sent on the next diagnostic request for the + # same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#33 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#59 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/related_full_document_diagnostic_report.rb#63 + def to_json(*args); end +end + +# An unchanged diagnostic report with a set of related documents. +# +# source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#7 +class LanguageServer::Protocol::Interface::RelatedUnchangedDocumentDiagnosticReport + # @return [RelatedUnchangedDocumentDiagnosticReport] a new instance of RelatedUnchangedDocumentDiagnosticReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#8 + def initialize(kind:, result_id:, related_documents: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#50 + def attributes; end + + # A document diagnostic report indicating + # no changes to the last result. A server can + # only return `unchanged` if result ids are + # provided. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#25 + def kind; end + + # Diagnostics of related documents. This information is useful + # in programming languages where code in a file A can generate + # diagnostics in a file B which A depends on. An example of + # such a language is C/C++ where marco definitions in a file + # a.cpp and result in errors in a header file b.hpp. + # + # @return [{ [uri: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#46 + def related_documents; end + + # A result id which will be sent on the next + # diagnostic request for the same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#34 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#52 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/related_unchanged_document_diagnostic_report.rb#56 + def to_json(*args); end +end + +# A relative pattern is a helper to construct glob patterns that are matched +# relatively to a base URI. The common value for a `baseUri` is a workspace +# folder root, but it can be another absolute URI as well. +# +# source://language_server-protocol//lib/language_server/protocol/interface/relative_pattern.rb#9 +class LanguageServer::Protocol::Interface::RelativePattern + # @return [RelativePattern] a new instance of RelativePattern + # + # source://language_server-protocol//lib/language_server/protocol/interface/relative_pattern.rb#10 + def initialize(base_uri:, pattern:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/relative_pattern.rb#36 + def attributes; end + + # A workspace folder or a base URI to which this pattern will be matched + # against relatively. + # + # @return [string | WorkspaceFolder] + # + # source://language_server-protocol//lib/language_server/protocol/interface/relative_pattern.rb#24 + def base_uri; end + + # The actual glob pattern; + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/relative_pattern.rb#32 + def pattern; end + + # source://language_server-protocol//lib/language_server/protocol/interface/relative_pattern.rb#38 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/relative_pattern.rb#42 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::RenameClientCapabilities + # @return [RenameClientCapabilities] a new instance of RenameClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), prepare_support: T.unsafe(nil), prepare_support_default_behavior: T.unsafe(nil), honors_change_annotations: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#57 + def attributes; end + + # Whether rename supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#20 + def dynamic_registration; end + + # Whether the client honors the change annotations in + # text edits and resource operations returned via the + # rename request's workspace edit by for example presenting + # the workspace edit in the user interface and asking + # for confirmation. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#53 + def honors_change_annotations; end + + # Client supports testing for validity of rename operations + # before execution. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#29 + def prepare_support; end + + # Client supports the default behavior result + # (`{ defaultBehavior: boolean }`). + # + # The value indicates the default behavior used by the + # client. + # + # @return [1] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#41 + def prepare_support_default_behavior; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#59 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_client_capabilities.rb#63 + def to_json(*args); end +end + +# Rename file operation +# +# source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#7 +class LanguageServer::Protocol::Interface::RenameFile + # @return [RenameFile] a new instance of RenameFile + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#8 + def initialize(kind:, old_uri:, new_uri:, options: T.unsafe(nil), annotation_id: T.unsafe(nil)); end + + # An optional annotation identifier describing the operation. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#56 + def annotation_id; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#60 + def attributes; end + + # A rename + # + # @return ["rename"] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#24 + def kind; end + + # The new location. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#40 + def new_uri; end + + # The old (existing) location. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#32 + def old_uri; end + + # Rename options. + # + # @return [RenameFileOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#48 + def options; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#62 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file.rb#66 + def to_json(*args); end +end + +# Rename file options +# +# source://language_server-protocol//lib/language_server/protocol/interface/rename_file_options.rb#7 +class LanguageServer::Protocol::Interface::RenameFileOptions + # @return [RenameFileOptions] a new instance of RenameFileOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file_options.rb#8 + def initialize(overwrite: T.unsafe(nil), ignore_if_exists: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file_options.rb#33 + def attributes; end + + # Ignores if target exists. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file_options.rb#29 + def ignore_if_exists; end + + # Overwrite target if existing. Overwrite wins over `ignoreIfExists` + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file_options.rb#21 + def overwrite; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file_options.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_file_options.rb#39 + def to_json(*args); end +end + +# The parameters sent in notifications/requests for user-initiated renames +# of files. +# +# source://language_server-protocol//lib/language_server/protocol/interface/rename_files_params.rb#8 +class LanguageServer::Protocol::Interface::RenameFilesParams + # @return [RenameFilesParams] a new instance of RenameFilesParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_files_params.rb#9 + def initialize(files:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_files_params.rb#26 + def attributes; end + + # An array of all files/folders renamed in this operation. When a folder + # is renamed, only the folder will be included, and not its children. + # + # @return [FileRename[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_files_params.rb#22 + def files; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_files_params.rb#28 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_files_params.rb#32 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/rename_options.rb#4 +class LanguageServer::Protocol::Interface::RenameOptions + # @return [RenameOptions] a new instance of RenameOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), prepare_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_options.rb#27 + def attributes; end + + # Renames should be checked and tested before being executed. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_options.rb#23 + def prepare_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_options.rb#29 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_options.rb#33 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_options.rb#15 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#4 +class LanguageServer::Protocol::Interface::RenameParams + # @return [RenameParams] a new instance of RenameParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#5 + def initialize(text_document:, position:, new_name:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#50 + def attributes; end + + # The new name of the symbol. If the given name is not valid the + # request must return a [ResponseError](#ResponseError) with an + # appropriate message set. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#46 + def new_name; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#52 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#56 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#4 +class LanguageServer::Protocol::Interface::RenameRegistrationOptions + # @return [RenameRegistrationOptions] a new instance of RenameRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), prepare_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#37 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#20 + def document_selector; end + + # Renames should be checked and tested before being executed. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#33 + def prepare_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#43 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/rename_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#4 +class LanguageServer::Protocol::Interface::RequestMessage + # @return [RequestMessage] a new instance of RequestMessage + # + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#5 + def initialize(jsonrpc:, id:, method:, params: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#45 + def attributes; end + + # The request id. + # + # @return [string | number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#25 + def id; end + + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#17 + def jsonrpc; end + + # The method to be invoked. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#33 + def method; end + + # The method's params. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#41 + def params; end + + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#47 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/request_message.rb#51 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#4 +class LanguageServer::Protocol::Interface::ResponseError + # @return [ResponseError] a new instance of ResponseError + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#5 + def initialize(code:, message:, data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#40 + def attributes; end + + # A number indicating the error type that occurred. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#19 + def code; end + + # A primitive or structured value that contains additional + # information about the error. Can be omitted. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#36 + def data; end + + # A string providing a short description of the error. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#27 + def message; end + + # source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/response_error.rb#46 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#4 +class LanguageServer::Protocol::Interface::ResponseMessage + # @return [ResponseMessage] a new instance of ResponseMessage + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#5 + def initialize(jsonrpc:, id:, result: T.unsafe(nil), error: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#46 + def attributes; end + + # The error object in case a request fails. + # + # @return [ResponseError] + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#42 + def error; end + + # The request id. + # + # @return [string | number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#25 + def id; end + + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#17 + def jsonrpc; end + + # The result of a request. This member is REQUIRED on success. + # This member MUST NOT exist if there was an error invoking the method. + # + # @return [string | number | boolean | object] + # + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#34 + def result; end + + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#48 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/response_message.rb#52 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/save_options.rb#4 +class LanguageServer::Protocol::Interface::SaveOptions + # @return [SaveOptions] a new instance of SaveOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/save_options.rb#5 + def initialize(include_text: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/save_options.rb#21 + def attributes; end + + # The client is supposed to include the content on save. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/save_options.rb#17 + def include_text; end + + # source://language_server-protocol//lib/language_server/protocol/interface/save_options.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/save_options.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/selection_range.rb#4 +class LanguageServer::Protocol::Interface::SelectionRange + # @return [SelectionRange] a new instance of SelectionRange + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range.rb#5 + def initialize(range:, parent: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range.rb#31 + def attributes; end + + # The parent selection range containing this range. Therefore + # `parent.range` must contain `this.range`. + # + # @return [SelectionRange] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range.rb#27 + def parent; end + + # The [range](#Range) of this selection range. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range.rb#18 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range.rb#37 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/selection_range_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::SelectionRangeClientCapabilities + # @return [SelectionRangeClientCapabilities] a new instance of SelectionRangeClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_client_capabilities.rb#24 + def attributes; end + + # Whether implementation supports dynamic registration for selection range + # providers. If this is set to `true` the client supports the new + # `SelectionRangeRegistrationOptions` return value for the corresponding + # server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_client_capabilities.rb#20 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_client_capabilities.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_client_capabilities.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/selection_range_options.rb#4 +class LanguageServer::Protocol::Interface::SelectionRangeOptions + # @return [SelectionRangeOptions] a new instance of SelectionRangeOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#4 +class LanguageServer::Protocol::Interface::SelectionRangeParams + # @return [SelectionRangeParams] a new instance of SelectionRangeParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#5 + def initialize(text_document:, positions:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#29 + def partial_result_token; end + + # The positions inside the text document. + # + # @return [Position[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#45 + def positions; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#37 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_params.rb#20 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#4 +class LanguageServer::Protocol::Interface::SelectionRangeRegistrationOptions + # @return [SelectionRangeRegistrationOptions] a new instance of SelectionRangeRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#25 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/selection_range_registration_options.rb#16 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokens + # @return [SemanticTokens] a new instance of SemanticTokens + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens.rb#5 + def initialize(data:, result_id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens.rb#33 + def attributes; end + + # The actual tokens. + # + # @return [number[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens.rb#29 + def data; end + + # An optional result id. If provided and clients support delta updating + # the client will include the result id in the next semantic token request. + # A server can then instead of computing all semantic tokens again simply + # send a delta. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens.rb#21 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens.rb#39 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensClientCapabilities + # @return [SemanticTokensClientCapabilities] a new instance of SemanticTokensClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#5 + def initialize(requests:, token_types:, token_modifiers:, formats:, dynamic_registration: T.unsafe(nil), overlapping_token_support: T.unsafe(nil), multiline_token_support: T.unsafe(nil), server_cancel_support: T.unsafe(nil), augments_syntax_tokens: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#113 + def attributes; end + + # Whether the client uses semantic tokens to augment existing + # syntax tokens. If set to `true` client side created syntax + # tokens and semantic tokens are both used for colorization. If + # set to `false` the client only uses the returned semantic tokens + # for colorization. + # + # If the value is `undefined` then the client behavior is not + # specified. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#109 + def augments_syntax_tokens; end + + # Whether implementation supports dynamic registration. If this is set to + # `true` the client supports the new `(TextDocumentRegistrationOptions & + # StaticRegistrationOptions)` return value for the corresponding server + # capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#28 + def dynamic_registration; end + + # The formats the clients supports. + # + # @return ["relative"[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#67 + def formats; end + + # Whether the client supports tokens that can span multiple lines. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#83 + def multiline_token_support; end + + # Whether the client supports tokens that can overlap each other. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#75 + def overlapping_token_support; end + + # Which requests the client supports and might send to the server + # depending on the server's capability. Please note that clients might not + # show semantic tokens or degrade some of the user experience if a range + # or full request is advertised by the client but not provided by the + # server. If for example the client capability `requests.full` and + # `request.range` are both set to true but the server only provides a + # range provider the client might not render a minimap correctly or might + # even decide to not show any semantic tokens at all. + # + # @return [{ range?: boolean | {}; full?: boolean | { delta?: boolean; }; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#43 + def requests; end + + # Whether the client allows the server to actively cancel a + # semantic token request, e.g. supports returning + # ErrorCodes.ServerCancelled. If a server does the client + # needs to retrigger the request. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#94 + def server_cancel_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#115 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#119 + def to_json(*args); end + + # The token modifiers that the client supports. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#59 + def token_modifiers; end + + # The token types that the client supports. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb#51 + def token_types; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensDelta + # @return [SemanticTokensDelta] a new instance of SemanticTokensDelta + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta.rb#5 + def initialize(edits:, result_id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta.rb#28 + def attributes; end + + # The semantic token edits to transform a previous result into a new + # result. + # + # @return [SemanticTokensEdit[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta.rb#24 + def edits; end + + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta.rb#15 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta.rb#34 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensDeltaParams + # @return [SemanticTokensDeltaParams] a new instance of SemanticTokensDeltaParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#5 + def initialize(text_document:, previous_result_id:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#50 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#29 + def partial_result_token; end + + # The result id of a previous response. The result Id can either point to + # a full response or a delta response depending on what was received last. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#46 + def previous_result_id; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#37 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#52 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#56 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_params.rb#20 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_partial_result.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensDeltaPartialResult + # @return [SemanticTokensDeltaPartialResult] a new instance of SemanticTokensDeltaPartialResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_partial_result.rb#5 + def initialize(edits:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_partial_result.rb#18 + def attributes; end + + # @return [SemanticTokensEdit[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_partial_result.rb#14 + def edits; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_partial_result.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_delta_partial_result.rb#24 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensEdit + # @return [SemanticTokensEdit] a new instance of SemanticTokensEdit + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#5 + def initialize(start:, delete_count:, data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#39 + def attributes; end + + # The elements to insert. + # + # @return [number[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#35 + def data; end + + # The count of elements to remove. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#27 + def delete_count; end + + # The start offset of the edit. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#19 + def start; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_edit.rb#45 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_legend.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensLegend + # @return [SemanticTokensLegend] a new instance of SemanticTokensLegend + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_legend.rb#5 + def initialize(token_types:, token_modifiers:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_legend.rb#30 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_legend.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_legend.rb#36 + def to_json(*args); end + + # The token modifiers a server uses. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_legend.rb#26 + def token_modifiers; end + + # The token types a server uses. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_legend.rb#18 + def token_types; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensOptions + # @return [SemanticTokensOptions] a new instance of SemanticTokensOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#5 + def initialize(legend:, work_done_progress: T.unsafe(nil), range: T.unsafe(nil), full: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#46 + def attributes; end + + # Server supports providing semantic tokens for a full document. + # + # @return [boolean | { delta?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#42 + def full; end + + # The legend used by the server + # + # @return [SemanticTokensLegend] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#25 + def legend; end + + # Server supports providing semantic tokens for a specific range + # of a document. + # + # @return [boolean | {}] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#34 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#48 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#52 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_options.rb#17 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensParams + # @return [SemanticTokensParams] a new instance of SemanticTokensParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#5 + def initialize(text_document:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#40 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#28 + def partial_result_token; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#36 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#42 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#46 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_partial_result.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensPartialResult + # @return [SemanticTokensPartialResult] a new instance of SemanticTokensPartialResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_partial_result.rb#5 + def initialize(data:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_partial_result.rb#18 + def attributes; end + + # @return [number[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_partial_result.rb#14 + def data; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_partial_result.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_partial_result.rb#24 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensRangeParams + # @return [SemanticTokensRangeParams] a new instance of SemanticTokensRangeParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#5 + def initialize(text_document:, range:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#29 + def partial_result_token; end + + # The range the semantic tokens are requested for. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#45 + def range; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#37 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_range_params.rb#20 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensRegistrationOptions + # @return [SemanticTokensRegistrationOptions] a new instance of SemanticTokensRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#5 + def initialize(document_selector:, legend:, work_done_progress: T.unsafe(nil), range: T.unsafe(nil), full: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#66 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#23 + def document_selector; end + + # Server supports providing semantic tokens for a full document. + # + # @return [boolean | { delta?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#53 + def full; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#62 + def id; end + + # The legend used by the server + # + # @return [SemanticTokensLegend] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#36 + def legend; end + + # Server supports providing semantic tokens for a specific range + # of a document. + # + # @return [boolean | {}] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#45 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#68 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#72 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_registration_options.rb#28 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_workspace_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::SemanticTokensWorkspaceClientCapabilities + # @return [SemanticTokensWorkspaceClientCapabilities] a new instance of SemanticTokensWorkspaceClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_workspace_client_capabilities.rb#5 + def initialize(refresh_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_workspace_client_capabilities.rb#27 + def attributes; end + + # Whether the client implementation supports a refresh request sent from + # the server to the client. + # + # Note that this event is global and will force the client to refresh all + # semantic tokens currently shown. It should be used with absolute care + # and is useful for situation where a server for example detect a project + # wide change that requires such a calculation. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_workspace_client_capabilities.rb#23 + def refresh_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_workspace_client_capabilities.rb#29 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/semantic_tokens_workspace_client_capabilities.rb#33 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#4 +class LanguageServer::Protocol::Interface::ServerCapabilities + # @return [ServerCapabilities] a new instance of ServerCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#5 + def initialize(position_encoding: T.unsafe(nil), text_document_sync: T.unsafe(nil), notebook_document_sync: T.unsafe(nil), completion_provider: T.unsafe(nil), hover_provider: T.unsafe(nil), signature_help_provider: T.unsafe(nil), declaration_provider: T.unsafe(nil), definition_provider: T.unsafe(nil), type_definition_provider: T.unsafe(nil), implementation_provider: T.unsafe(nil), references_provider: T.unsafe(nil), document_highlight_provider: T.unsafe(nil), document_symbol_provider: T.unsafe(nil), code_action_provider: T.unsafe(nil), code_lens_provider: T.unsafe(nil), document_link_provider: T.unsafe(nil), color_provider: T.unsafe(nil), document_formatting_provider: T.unsafe(nil), document_range_formatting_provider: T.unsafe(nil), document_on_type_formatting_provider: T.unsafe(nil), rename_provider: T.unsafe(nil), folding_range_provider: T.unsafe(nil), execute_command_provider: T.unsafe(nil), selection_range_provider: T.unsafe(nil), linked_editing_range_provider: T.unsafe(nil), call_hierarchy_provider: T.unsafe(nil), semantic_tokens_provider: T.unsafe(nil), moniker_provider: T.unsafe(nil), type_hierarchy_provider: T.unsafe(nil), inline_value_provider: T.unsafe(nil), inlay_hint_provider: T.unsafe(nil), diagnostic_provider: T.unsafe(nil), workspace_symbol_provider: T.unsafe(nil), workspace: T.unsafe(nil), experimental: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#340 + def attributes; end + + # The server provides call hierarchy support. + # + # @return [boolean | CallHierarchyOptions | CallHierarchyRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#264 + def call_hierarchy_provider; end + + # The server provides code actions. The `CodeActionOptions` return type is + # only valid if the client signals code action literal support via the + # property `textDocument.codeAction.codeActionLiteralSupport`. + # + # @return [boolean | CodeActionOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#166 + def code_action_provider; end + + # The server provides code lens. + # + # @return [CodeLensOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#174 + def code_lens_provider; end + + # The server provides color provider support. + # + # @return [boolean | DocumentColorOptions | DocumentColorRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#190 + def color_provider; end + + # The server provides completion support. + # + # @return [CompletionOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#84 + def completion_provider; end + + # The server provides go to declaration support. + # + # @return [boolean | DeclarationOptions | DeclarationRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#108 + def declaration_provider; end + + # The server provides goto definition support. + # + # @return [boolean | DefinitionOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#116 + def definition_provider; end + + # The server has support for pull model diagnostics. + # + # @return [DiagnosticOptions | DiagnosticRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#312 + def diagnostic_provider; end + + # The server provides document formatting. + # + # @return [boolean | DocumentFormattingOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#198 + def document_formatting_provider; end + + # The server provides document highlight support. + # + # @return [boolean | DocumentHighlightOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#148 + def document_highlight_provider; end + + # The server provides document link support. + # + # @return [DocumentLinkOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#182 + def document_link_provider; end + + # The server provides document formatting on typing. + # + # @return [DocumentOnTypeFormattingOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#214 + def document_on_type_formatting_provider; end + + # The server provides document range formatting. + # + # @return [boolean | DocumentRangeFormattingOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#206 + def document_range_formatting_provider; end + + # The server provides document symbol support. + # + # @return [boolean | DocumentSymbolOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#156 + def document_symbol_provider; end + + # The server provides execute command support. + # + # @return [ExecuteCommandOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#240 + def execute_command_provider; end + + # Experimental server capabilities. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#336 + def experimental; end + + # The server provides folding provider support. + # + # @return [boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#232 + def folding_range_provider; end + + # The server provides hover support. + # + # @return [boolean | HoverOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#92 + def hover_provider; end + + # The server provides goto implementation support. + # + # @return [boolean | ImplementationOptions | ImplementationRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#132 + def implementation_provider; end + + # The server provides inlay hints. + # + # @return [boolean | InlayHintOptions | InlayHintRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#304 + def inlay_hint_provider; end + + # The server provides inline values. + # + # @return [boolean | InlineValueOptions | InlineValueRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#296 + def inline_value_provider; end + + # The server provides linked editing range support. + # + # @return [boolean | LinkedEditingRangeOptions | LinkedEditingRangeRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#256 + def linked_editing_range_provider; end + + # Whether server provides moniker support. + # + # @return [boolean | MonikerOptions | MonikerRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#280 + def moniker_provider; end + + # Defines how notebook documents are synced. + # + # @return [NotebookDocumentSyncOptions | NotebookDocumentSyncRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#76 + def notebook_document_sync; end + + # The position encoding the server picked from the encodings offered + # by the client via the client capability `general.positionEncodings`. + # + # If the client didn't provide any position encodings the only valid + # value that a server can return is 'utf-16'. + # + # If omitted it defaults to 'utf-16'. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#57 + def position_encoding; end + + # The server provides find references support. + # + # @return [boolean | ReferenceOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#140 + def references_provider; end + + # The server provides rename support. RenameOptions may only be + # specified if the client states that it supports + # `prepareSupport` in its initial `initialize` request. + # + # @return [boolean | RenameOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#224 + def rename_provider; end + + # The server provides selection range support. + # + # @return [boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#248 + def selection_range_provider; end + + # The server provides semantic tokens support. + # + # @return [SemanticTokensOptions | SemanticTokensRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#272 + def semantic_tokens_provider; end + + # The server provides signature help support. + # + # @return [SignatureHelpOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#100 + def signature_help_provider; end + + # Defines how text documents are synced. Is either a detailed structure + # defining each notification or for backwards compatibility the + # TextDocumentSyncKind number. If omitted it defaults to + # `TextDocumentSyncKind.None`. + # + # @return [TextDocumentSyncOptions | TextDocumentSyncKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#68 + def text_document_sync; end + + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#342 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#346 + def to_json(*args); end + + # The server provides goto type definition support. + # + # @return [boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#124 + def type_definition_provider; end + + # The server provides type hierarchy support. + # + # @return [boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#288 + def type_hierarchy_provider; end + + # Workspace specific server capabilities + # + # @return [{ workspaceFolders?: WorkspaceFoldersServerCapabilities; fileOperations?: { didCreate?: FileOperationRegistrationOptions; ... 4 more ...; willDelete?: FileOperationRegistrationOptions; }; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#328 + def workspace; end + + # The server provides workspace symbol support. + # + # @return [boolean | WorkspaceSymbolOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/server_capabilities.rb#320 + def workspace_symbol_provider; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/set_trace_params.rb#4 +class LanguageServer::Protocol::Interface::SetTraceParams + # @return [SetTraceParams] a new instance of SetTraceParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/set_trace_params.rb#5 + def initialize(value:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/set_trace_params.rb#21 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/set_trace_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/set_trace_params.rb#27 + def to_json(*args); end + + # The new value that should be assigned to the trace setting. + # + # @return [TraceValue] + # + # source://language_server-protocol//lib/language_server/protocol/interface/set_trace_params.rb#17 + def value; end +end + +# Client capabilities for the show document request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/show_document_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::ShowDocumentClientCapabilities + # @return [ShowDocumentClientCapabilities] a new instance of ShowDocumentClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_client_capabilities.rb#8 + def initialize(support:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_client_capabilities.rb#25 + def attributes; end + + # The client has support for the show document + # request. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_client_capabilities.rb#21 + def support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_client_capabilities.rb#27 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_client_capabilities.rb#31 + def to_json(*args); end +end + +# Params to show a resource. +# +# source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#7 +class LanguageServer::Protocol::Interface::ShowDocumentParams + # @return [ShowDocumentParams] a new instance of ShowDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#8 + def initialize(uri:, external: T.unsafe(nil), take_focus: T.unsafe(nil), selection: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#59 + def attributes; end + + # Indicates to show the resource in an external program. + # To show, for example, `https://code.visualstudio.com/` + # in the default WEB browser set `external` to `true`. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#33 + def external; end + + # An optional selection range if the document is a text + # document. Clients might ignore the property if an + # external program is started or the file is not a text + # file. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#55 + def selection; end + + # An optional property to indicate whether the editor + # showing the document should take focus or not. + # Clients might ignore this property if an external + # program is started. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#44 + def take_focus; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#61 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#65 + def to_json(*args); end + + # The uri to show. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_params.rb#23 + def uri; end +end + +# The result of an show document request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/show_document_result.rb#7 +class LanguageServer::Protocol::Interface::ShowDocumentResult + # @return [ShowDocumentResult] a new instance of ShowDocumentResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_result.rb#8 + def initialize(success:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_result.rb#24 + def attributes; end + + # A boolean indicating if the show was successful. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_result.rb#20 + def success; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_result.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_document_result.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/show_message_params.rb#4 +class LanguageServer::Protocol::Interface::ShowMessageParams + # @return [ShowMessageParams] a new instance of ShowMessageParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_params.rb#5 + def initialize(type:, message:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_params.rb#30 + def attributes; end + + # The actual message. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_params.rb#26 + def message; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_params.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_params.rb#36 + def to_json(*args); end + + # The message type. See {@link MessageType}. + # + # @return [MessageType] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_params.rb#18 + def type; end +end + +# Show message request client capabilities +# +# source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::ShowMessageRequestClientCapabilities + # @return [ShowMessageRequestClientCapabilities] a new instance of ShowMessageRequestClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_client_capabilities.rb#8 + def initialize(message_action_item: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_client_capabilities.rb#24 + def attributes; end + + # Capabilities specific to the `MessageActionItem` type. + # + # @return [{ additionalPropertiesSupport?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_client_capabilities.rb#20 + def message_action_item; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_client_capabilities.rb#26 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_client_capabilities.rb#30 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#4 +class LanguageServer::Protocol::Interface::ShowMessageRequestParams + # @return [ShowMessageRequestParams] a new instance of ShowMessageRequestParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#5 + def initialize(type:, message:, actions: T.unsafe(nil)); end + + # The message action items to present. + # + # @return [MessageActionItem[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#35 + def actions; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#39 + def attributes; end + + # The actual message + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#27 + def message; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#45 + def to_json(*args); end + + # The message type. See {@link MessageType} + # + # @return [MessageType] + # + # source://language_server-protocol//lib/language_server/protocol/interface/show_message_request_params.rb#19 + def type; end +end + +# Signature help represents the signature of something +# callable. There can be multiple signature but only one +# active and only one active parameter. +# +# source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#9 +class LanguageServer::Protocol::Interface::SignatureHelp + # @return [SignatureHelp] a new instance of SignatureHelp + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#10 + def initialize(signatures:, active_signature: T.unsafe(nil), active_parameter: T.unsafe(nil)); end + + # The active parameter of the active signature. If omitted or the value + # lies outside the range of `signatures[activeSignature].parameters` + # defaults to 0 if the active signature has parameters. If + # the active signature has no parameters it is ignored. + # In future version of the protocol this property might become + # mandatory to better express the active parameter if the + # active signature does have any. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#55 + def active_parameter; end + + # The active signature. If omitted or the value lies outside the + # range of `signatures` the value defaults to zero or is ignore if + # the `SignatureHelp` as no signatures. + # + # Whenever possible implementors should make an active decision about + # the active signature and shouldn't rely on a default value. + # + # In future version of the protocol this property might become + # mandatory to better express this. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#41 + def active_signature; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#59 + def attributes; end + + # One or more signatures. If no signatures are available the signature help + # request should return `null`. + # + # @return [SignatureInformation[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#25 + def signatures; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#61 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help.rb#65 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::SignatureHelpClientCapabilities + # @return [SignatureHelpClientCapabilities] a new instance of SignatureHelpClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), signature_information: T.unsafe(nil), context_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#43 + def attributes; end + + # The client supports to send additional context information for a + # `textDocument/signatureHelp` request. A client that opts into + # contextSupport will also support the `retriggerCharacters` on + # `SignatureHelpOptions`. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#39 + def context_support; end + + # Whether signature help supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#19 + def dynamic_registration; end + + # The client supports the following `SignatureInformation` + # specific properties. + # + # @return [{ documentationFormat?: MarkupKind[]; parameterInformation?: { labelOffsetSupport?: boolean; }; activeParameterSupport?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#28 + def signature_information; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#45 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_client_capabilities.rb#49 + def to_json(*args); end +end + +# Additional information about the context in which a signature help request +# was triggered. +# +# source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#8 +class LanguageServer::Protocol::Interface::SignatureHelpContext + # @return [SignatureHelpContext] a new instance of SignatureHelpContext + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#9 + def initialize(trigger_kind:, is_retrigger:, trigger_character: T.unsafe(nil), active_signature_help: T.unsafe(nil)); end + + # The currently active `SignatureHelp`. + # + # The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field + # updated based on the user navigating through available signatures. + # + # @return [SignatureHelp] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#58 + def active_signature_help; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#62 + def attributes; end + + # `true` if signature help was already showing when it was triggered. + # + # Retriggers occur when the signature help is already active and can be + # caused by actions such as typing a trigger character, a cursor move, or + # document content changes. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#47 + def is_retrigger; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#64 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#68 + def to_json(*args); end + + # Character that caused signature help to be triggered. + # + # This is undefined when triggerKind !== + # SignatureHelpTriggerKind.TriggerCharacter + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#35 + def trigger_character; end + + # Action that caused signature help to be triggered. + # + # @return [SignatureHelpTriggerKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_context.rb#24 + def trigger_kind; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#4 +class LanguageServer::Protocol::Interface::SignatureHelpOptions + # @return [SignatureHelpOptions] a new instance of SignatureHelpOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), trigger_characters: T.unsafe(nil), retrigger_characters: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#41 + def attributes; end + + # List of characters that re-trigger signature help. + # + # These trigger characters are only active when signature help is already + # showing. All trigger characters are also counted as re-trigger + # characters. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#37 + def retrigger_characters; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#43 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#47 + def to_json(*args); end + + # The characters that trigger signature help + # automatically. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#25 + def trigger_characters; end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_options.rb#16 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#4 +class LanguageServer::Protocol::Interface::SignatureHelpParams + # @return [SignatureHelpParams] a new instance of SignatureHelpParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), context: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#50 + def attributes; end + + # The signature help context. This is only available if the client + # specifies to send this using the client capability + # `textDocument.signatureHelp.contextSupport === true` + # + # @return [SignatureHelpContext] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#46 + def context; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#52 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#56 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#4 +class LanguageServer::Protocol::Interface::SignatureHelpRegistrationOptions + # @return [SignatureHelpRegistrationOptions] a new instance of SignatureHelpRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), trigger_characters: T.unsafe(nil), retrigger_characters: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#51 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#21 + def document_selector; end + + # List of characters that re-trigger signature help. + # + # These trigger characters are only active when signature help is already + # showing. All trigger characters are also counted as re-trigger + # characters. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#47 + def retrigger_characters; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#53 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#57 + def to_json(*args); end + + # The characters that trigger signature help + # automatically. + # + # @return [string[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#35 + def trigger_characters; end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_help_registration_options.rb#26 + def work_done_progress; end +end + +# Represents the signature of something callable. A signature +# can have a label, like a function-name, a doc-comment, and +# a set of parameters. +# +# source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#9 +class LanguageServer::Protocol::Interface::SignatureInformation + # @return [SignatureInformation] a new instance of SignatureInformation + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#10 + def initialize(label:, documentation: T.unsafe(nil), parameters: T.unsafe(nil), active_parameter: T.unsafe(nil)); end + + # The index of the active parameter. + # + # If provided, this is used in place of `SignatureHelp.activeParameter`. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#53 + def active_parameter; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#57 + def attributes; end + + # The human-readable doc-comment of this signature. Will be shown + # in the UI but can be omitted. + # + # @return [string | MarkupContent] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#35 + def documentation; end + + # The label of this signature. Will be shown in + # the UI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#26 + def label; end + + # The parameters of this signature. + # + # @return [ParameterInformation[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#43 + def parameters; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#59 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/signature_information.rb#63 + def to_json(*args); end +end + +# Static registration options to be returned in the initialize request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/static_registration_options.rb#7 +class LanguageServer::Protocol::Interface::StaticRegistrationOptions + # @return [StaticRegistrationOptions] a new instance of StaticRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/static_registration_options.rb#8 + def initialize(id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/static_registration_options.rb#25 + def attributes; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/static_registration_options.rb#21 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/static_registration_options.rb#27 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/static_registration_options.rb#31 + def to_json(*args); end +end + +# Represents information about programming constructs like variables, classes, +# interfaces etc. +# +# source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#8 +class LanguageServer::Protocol::Interface::SymbolInformation + # @return [SymbolInformation] a new instance of SymbolInformation + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#9 + def initialize(name:, kind:, location:, tags: T.unsafe(nil), deprecated: T.unsafe(nil), container_name: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#81 + def attributes; end + + # The name of the symbol containing this symbol. This information is for + # user interface purposes (e.g. to render a qualifier in the user interface + # if necessary). It can't be used to re-infer a hierarchy for the document + # symbols. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#77 + def container_name; end + + # Indicates if this symbol is deprecated. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#50 + def deprecated; end + + # The kind of this symbol. + # + # @return [SymbolKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#34 + def kind; end + + # The location of this symbol. The location's range is used by a tool + # to reveal the location in the editor. If the symbol is selected in the + # tool the range's start information is used to position the cursor. So + # the range usually spans more then the actual symbol's name and does + # normally include things like visibility modifiers. + # + # The range doesn't have to denote a node range in the sense of an abstract + # syntax tree. It can therefore not be used to re-construct a hierarchy of + # the symbols. + # + # @return [Location] + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#66 + def location; end + + # The name of this symbol. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#26 + def name; end + + # Tags for this symbol. + # + # @return [1[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#42 + def tags; end + + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#83 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/symbol_information.rb#87 + def to_json(*args); end +end + +# Describe options to be used when registering for text document change events. +# +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_change_registration_options.rb#7 +class LanguageServer::Protocol::Interface::TextDocumentChangeRegistrationOptions + # @return [TextDocumentChangeRegistrationOptions] a new instance of TextDocumentChangeRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_change_registration_options.rb#8 + def initialize(document_selector:, sync_kind:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_change_registration_options.rb#35 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_change_registration_options.rb#22 + def document_selector; end + + # How documents are synced to the server. See TextDocumentSyncKind.Full + # and TextDocumentSyncKind.Incremental. + # + # @return [TextDocumentSyncKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_change_registration_options.rb#31 + def sync_kind; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_change_registration_options.rb#37 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_change_registration_options.rb#41 + def to_json(*args); end +end + +# Text document specific client capabilities. +# +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#7 +class LanguageServer::Protocol::Interface::TextDocumentClientCapabilities + # @return [TextDocumentClientCapabilities] a new instance of TextDocumentClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#8 + def initialize(synchronization: T.unsafe(nil), completion: T.unsafe(nil), hover: T.unsafe(nil), signature_help: T.unsafe(nil), declaration: T.unsafe(nil), definition: T.unsafe(nil), type_definition: T.unsafe(nil), implementation: T.unsafe(nil), references: T.unsafe(nil), document_highlight: T.unsafe(nil), document_symbol: T.unsafe(nil), code_action: T.unsafe(nil), code_lens: T.unsafe(nil), document_link: T.unsafe(nil), color_provider: T.unsafe(nil), formatting: T.unsafe(nil), range_formatting: T.unsafe(nil), on_type_formatting: T.unsafe(nil), rename: T.unsafe(nil), publish_diagnostics: T.unsafe(nil), folding_range: T.unsafe(nil), selection_range: T.unsafe(nil), linked_editing_range: T.unsafe(nil), call_hierarchy: T.unsafe(nil), semantic_tokens: T.unsafe(nil), moniker: T.unsafe(nil), type_hierarchy: T.unsafe(nil), inline_value: T.unsafe(nil), inlay_hint: T.unsafe(nil), diagnostic: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#285 + def attributes; end + + # Capabilities specific to the various call hierarchy requests. + # + # @return [CallHierarchyClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#233 + def call_hierarchy; end + + # Capabilities specific to the `textDocument/codeAction` request. + # + # @return [CodeActionClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#134 + def code_action; end + + # Capabilities specific to the `textDocument/codeLens` request. + # + # @return [CodeLensClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#142 + def code_lens; end + + # Capabilities specific to the `textDocument/documentColor` and the + # `textDocument/colorPresentation` request. + # + # @return [DocumentColorClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#159 + def color_provider; end + + # Capabilities specific to the `textDocument/completion` request. + # + # @return [CompletionClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#54 + def completion; end + + # Capabilities specific to the `textDocument/declaration` request. + # + # @return [DeclarationClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#78 + def declaration; end + + # Capabilities specific to the `textDocument/definition` request. + # + # @return [DefinitionClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#86 + def definition; end + + # Capabilities specific to the diagnostic pull model. + # + # @return [DiagnosticClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#281 + def diagnostic; end + + # Capabilities specific to the `textDocument/documentHighlight` request. + # + # @return [DocumentHighlightClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#118 + def document_highlight; end + + # Capabilities specific to the `textDocument/documentLink` request. + # + # @return [DocumentLinkClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#150 + def document_link; end + + # Capabilities specific to the `textDocument/documentSymbol` request. + # + # @return [DocumentSymbolClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#126 + def document_symbol; end + + # Capabilities specific to the `textDocument/foldingRange` request. + # + # @return [FoldingRangeClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#209 + def folding_range; end + + # Capabilities specific to the `textDocument/formatting` request. + # + # @return [DocumentFormattingClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#167 + def formatting; end + + # Capabilities specific to the `textDocument/hover` request. + # + # @return [HoverClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#62 + def hover; end + + # Capabilities specific to the `textDocument/implementation` request. + # + # @return [ImplementationClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#102 + def implementation; end + + # Capabilities specific to the `textDocument/inlayHint` request. + # + # @return [InlayHintClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#273 + def inlay_hint; end + + # Capabilities specific to the `textDocument/inlineValue` request. + # + # @return [InlineValueClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#265 + def inline_value; end + + # Capabilities specific to the `textDocument/linkedEditingRange` request. + # + # @return [LinkedEditingRangeClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#225 + def linked_editing_range; end + + # Capabilities specific to the `textDocument/moniker` request. + # + # @return [MonikerClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#249 + def moniker; end + + # request. + # Capabilities specific to the `textDocument/onTypeFormatting` request. + # + # @return [DocumentOnTypeFormattingClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#184 + def on_type_formatting; end + + # Capabilities specific to the `textDocument/publishDiagnostics` + # notification. + # + # @return [PublishDiagnosticsClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#201 + def publish_diagnostics; end + + # Capabilities specific to the `textDocument/rangeFormatting` request. + # + # @return [DocumentRangeFormattingClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#175 + def range_formatting; end + + # Capabilities specific to the `textDocument/references` request. + # + # @return [ReferenceClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#110 + def references; end + + # Capabilities specific to the `textDocument/rename` request. + # + # @return [RenameClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#192 + def rename; end + + # Capabilities specific to the `textDocument/selectionRange` request. + # + # @return [SelectionRangeClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#217 + def selection_range; end + + # Capabilities specific to the various semantic token requests. + # + # @return [SemanticTokensClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#241 + def semantic_tokens; end + + # Capabilities specific to the `textDocument/signatureHelp` request. + # + # @return [SignatureHelpClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#70 + def signature_help; end + + # @return [TextDocumentSyncClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#46 + def synchronization; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#287 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#291 + def to_json(*args); end + + # Capabilities specific to the `textDocument/typeDefinition` request. + # + # @return [TypeDefinitionClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#94 + def type_definition; end + + # Capabilities specific to the various type hierarchy requests. + # + # @return [TypeHierarchyClientCapabilities] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_client_capabilities.rb#257 + def type_hierarchy; end +end + +# An event describing a change to a text document. If only a text is provided +# it is considered to be the full content of the document. +# +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#8 +class LanguageServer::Protocol::Interface::TextDocumentContentChangeEvent + # @return [TextDocumentContentChangeEvent] a new instance of TextDocumentContentChangeEvent + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#9 + def initialize(text:, range: T.unsafe(nil), range_length: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#47 + def attributes; end + + # The range of the document that changed. + # + # @return [Range, nil] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#23 + def range; end + + # The optional length of the range that got replaced. + # + # @return [number, nil] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#31 + def range_length; end + + # The new text for the provided range. + # + # --- OR --- + # + # The new text of the whole document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#43 + def text; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#49 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_content_change_event.rb#53 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_edit.rb#4 +class LanguageServer::Protocol::Interface::TextDocumentEdit + # @return [TextDocumentEdit] a new instance of TextDocumentEdit + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_edit.rb#5 + def initialize(text_document:, edits:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_edit.rb#30 + def attributes; end + + # The edits to be applied. + # + # @return [(TextEdit | AnnotatedTextEdit)[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_edit.rb#26 + def edits; end + + # The text document to change. + # + # @return [OptionalVersionedTextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_edit.rb#18 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_edit.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_edit.rb#36 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_identifier.rb#4 +class LanguageServer::Protocol::Interface::TextDocumentIdentifier + # @return [TextDocumentIdentifier] a new instance of TextDocumentIdentifier + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_identifier.rb#5 + def initialize(uri:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_identifier.rb#21 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_identifier.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_identifier.rb#27 + def to_json(*args); end + + # The text document's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_identifier.rb#17 + def uri; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#4 +class LanguageServer::Protocol::Interface::TextDocumentItem + # @return [TextDocumentItem] a new instance of TextDocumentItem + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#5 + def initialize(uri:, language_id:, version:, text:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#49 + def attributes; end + + # The text document's language identifier. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#28 + def language_id; end + + # The content of the opened text document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#45 + def text; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#55 + def to_json(*args); end + + # The text document's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#20 + def uri; end + + # The version number of this document (it will increase after each + # change, including undo/redo). + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_item.rb#37 + def version; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_position_params.rb#4 +class LanguageServer::Protocol::Interface::TextDocumentPositionParams + # @return [TextDocumentPositionParams] a new instance of TextDocumentPositionParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_position_params.rb#5 + def initialize(text_document:, position:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_position_params.rb#30 + def attributes; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_position_params.rb#26 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_position_params.rb#18 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_position_params.rb#32 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_position_params.rb#36 + def to_json(*args); end +end + +# General text document registration options. +# +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_registration_options.rb#7 +class LanguageServer::Protocol::Interface::TextDocumentRegistrationOptions + # @return [TextDocumentRegistrationOptions] a new instance of TextDocumentRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_registration_options.rb#8 + def initialize(document_selector:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_registration_options.rb#25 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_registration_options.rb#21 + def document_selector; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_registration_options.rb#27 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_registration_options.rb#31 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_save_registration_options.rb#4 +class LanguageServer::Protocol::Interface::TextDocumentSaveRegistrationOptions + # @return [TextDocumentSaveRegistrationOptions] a new instance of TextDocumentSaveRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_save_registration_options.rb#5 + def initialize(document_selector:, include_text: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_save_registration_options.rb#31 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_save_registration_options.rb#19 + def document_selector; end + + # The client is supposed to include the content on save. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_save_registration_options.rb#27 + def include_text; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_save_registration_options.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_save_registration_options.rb#37 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::TextDocumentSyncClientCapabilities + # @return [TextDocumentSyncClientCapabilities] a new instance of TextDocumentSyncClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), will_save: T.unsafe(nil), will_save_wait_until: T.unsafe(nil), did_save: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#50 + def attributes; end + + # The client supports did save notifications. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#46 + def did_save; end + + # Whether text document synchronization supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#20 + def dynamic_registration; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#52 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#56 + def to_json(*args); end + + # The client supports sending will save notifications. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#28 + def will_save; end + + # The client supports sending a will save request and + # waits for a response providing text edits which will + # be applied to the document before it is saved. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_client_capabilities.rb#38 + def will_save_wait_until; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#4 +class LanguageServer::Protocol::Interface::TextDocumentSyncOptions + # @return [TextDocumentSyncOptions] a new instance of TextDocumentSyncOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#5 + def initialize(open_close: T.unsafe(nil), change: T.unsafe(nil), will_save: T.unsafe(nil), will_save_wait_until: T.unsafe(nil), save: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#66 + def attributes; end + + # Change notifications are sent to the server. See + # TextDocumentSyncKind.None, TextDocumentSyncKind.Full and + # TextDocumentSyncKind.Incremental. If omitted it defaults to + # TextDocumentSyncKind.None. + # + # @return [TextDocumentSyncKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#35 + def change; end + + # Open and close notifications are sent to the server. If omitted open + # close notifications should not be sent. + # Open and close notifications are sent to the server. If omitted open + # close notification should not be sent. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#24 + def open_close; end + + # If present save notifications are sent to the server. If omitted the + # notification should not be sent. + # + # @return [boolean | SaveOptions] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#62 + def save; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#68 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#72 + def to_json(*args); end + + # If present will save notifications are sent to the server. If omitted + # the notification should not be sent. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#44 + def will_save; end + + # If present will save wait until requests are sent to the server. If + # omitted the request should not be sent. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_document_sync_options.rb#53 + def will_save_wait_until; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/text_edit.rb#4 +class LanguageServer::Protocol::Interface::TextEdit + # @return [TextEdit] a new instance of TextEdit + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_edit.rb#5 + def initialize(range:, new_text:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_edit.rb#32 + def attributes; end + + # The string to be inserted. For delete operations use an + # empty string. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_edit.rb#28 + def new_text; end + + # The range of the text document to be manipulated. To insert + # text into a document create a range where start === end. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/text_edit.rb#19 + def range; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_edit.rb#34 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/text_edit.rb#38 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_definition_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::TypeDefinitionClientCapabilities + # @return [TypeDefinitionClientCapabilities] a new instance of TypeDefinitionClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), link_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_client_capabilities.rb#32 + def attributes; end + + # Whether implementation supports dynamic registration. If this is set to + # `true` the client supports the new `TypeDefinitionRegistrationOptions` + # return value for the corresponding server capability as well. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_client_capabilities.rb#20 + def dynamic_registration; end + + # The client supports additional metadata in the form of definition links. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_client_capabilities.rb#28 + def link_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_client_capabilities.rb#34 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_client_capabilities.rb#38 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_definition_options.rb#4 +class LanguageServer::Protocol::Interface::TypeDefinitionOptions + # @return [TypeDefinitionOptions] a new instance of TypeDefinitionOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#4 +class LanguageServer::Protocol::Interface::TypeDefinitionParams + # @return [TypeDefinitionParams] a new instance of TypeDefinitionParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#49 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#45 + def partial_result_token; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#28 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#20 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#51 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#55 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_params.rb#36 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#4 +class LanguageServer::Protocol::Interface::TypeDefinitionRegistrationOptions + # @return [TypeDefinitionRegistrationOptions] a new instance of TypeDefinitionRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#20 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_definition_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#4 +class LanguageServer::Protocol::Interface::TypeHierarchyItem + # @return [TypeHierarchyItem] a new instance of TypeHierarchyItem + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#5 + def initialize(name:, kind:, uri:, range:, selection_range:, tags: T.unsafe(nil), detail: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#90 + def attributes; end + + # A data entry field that is preserved between a type hierarchy prepare and + # supertypes or subtypes requests. It could also be used to identify the + # type hierarchy in the server, helping improve the performance on + # resolving supertypes and subtypes. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#86 + def data; end + + # More detail for this item, e.g. the signature of a function. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#48 + def detail; end + + # The kind of this item. + # + # @return [SymbolKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#32 + def kind; end + + # The name of this item. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#24 + def name; end + + # The range enclosing this symbol not including leading/trailing whitespace + # but everything else, e.g. comments and code. + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#65 + def range; end + + # The range that should be selected and revealed when this symbol is being + # picked, e.g. the name of a function. Must be contained by the + # [`range`](#TypeHierarchyItem.range). + # + # @return [Range] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#75 + def selection_range; end + + # Tags for this item. + # + # @return [1[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#40 + def tags; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#92 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#96 + def to_json(*args); end + + # The resource identifier of this item. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_item.rb#56 + def uri; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_options.rb#4 +class LanguageServer::Protocol::Interface::TypeHierarchyOptions + # @return [TypeHierarchyOptions] a new instance of TypeHierarchyOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#4 +class LanguageServer::Protocol::Interface::TypeHierarchyPrepareParams + # @return [TypeHierarchyPrepareParams] a new instance of TypeHierarchyPrepareParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#5 + def initialize(text_document:, position:, work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#39 + def attributes; end + + # The position inside the text document. + # + # @return [Position] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#27 + def position; end + + # The text document. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#19 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#41 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#45 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_prepare_params.rb#35 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#4 +class LanguageServer::Protocol::Interface::TypeHierarchyRegistrationOptions + # @return [TypeHierarchyRegistrationOptions] a new instance of TypeHierarchyRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#5 + def initialize(document_selector:, work_done_progress: T.unsafe(nil), id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#38 + def attributes; end + + # A document selector to identify the scope of the registration. If set to + # null the document selector provided on the client side will be used. + # + # @return [DocumentSelector] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#20 + def document_selector; end + + # The id used to register the request. The id can be used to deregister + # the request again. See also Registration#id. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#34 + def id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#44 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_registration_options.rb#25 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#4 +class LanguageServer::Protocol::Interface::TypeHierarchySubtypesParams + # @return [TypeHierarchySubtypesParams] a new instance of TypeHierarchySubtypesParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#5 + def initialize(item:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#37 + def attributes; end + + # @return [TypeHierarchyItem] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#33 + def item; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#28 + def partial_result_token; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#43 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_subtypes_params.rb#19 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#4 +class LanguageServer::Protocol::Interface::TypeHierarchySupertypesParams + # @return [TypeHierarchySupertypesParams] a new instance of TypeHierarchySupertypesParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#5 + def initialize(item:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#37 + def attributes; end + + # @return [TypeHierarchyItem] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#33 + def item; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#28 + def partial_result_token; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#39 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#43 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/type_hierarchy_supertypes_params.rb#19 + def work_done_token; end +end + +# A diagnostic report indicating that the last returned +# report is still accurate. +# +# source://language_server-protocol//lib/language_server/protocol/interface/unchanged_document_diagnostic_report.rb#8 +class LanguageServer::Protocol::Interface::UnchangedDocumentDiagnosticReport + # @return [UnchangedDocumentDiagnosticReport] a new instance of UnchangedDocumentDiagnosticReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/unchanged_document_diagnostic_report.rb#9 + def initialize(kind:, result_id:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/unchanged_document_diagnostic_report.rb#38 + def attributes; end + + # A document diagnostic report indicating + # no changes to the last result. A server can + # only return `unchanged` if result ids are + # provided. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/unchanged_document_diagnostic_report.rb#25 + def kind; end + + # A result id which will be sent on the next + # diagnostic request for the same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/unchanged_document_diagnostic_report.rb#34 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/unchanged_document_diagnostic_report.rb#40 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/unchanged_document_diagnostic_report.rb#44 + def to_json(*args); end +end + +# General parameters to unregister a capability. +# +# source://language_server-protocol//lib/language_server/protocol/interface/unregistration.rb#7 +class LanguageServer::Protocol::Interface::Unregistration + # @return [Unregistration] a new instance of Unregistration + # + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration.rb#8 + def initialize(id:, method:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration.rb#34 + def attributes; end + + # The id used to unregister the request or notification. Usually an id + # provided during the register request. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration.rb#22 + def id; end + + # The method / capability to unregister for. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration.rb#30 + def method; end + + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration.rb#36 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration.rb#40 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/unregistration_params.rb#4 +class LanguageServer::Protocol::Interface::UnregistrationParams + # @return [UnregistrationParams] a new instance of UnregistrationParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration_params.rb#5 + def initialize(unregisterations:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration_params.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration_params.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration_params.rb#24 + def to_json(*args); end + + # @return [Unregistration[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/unregistration_params.rb#14 + def unregisterations; end +end + +# A versioned notebook document identifier. +# +# source://language_server-protocol//lib/language_server/protocol/interface/versioned_notebook_document_identifier.rb#7 +class LanguageServer::Protocol::Interface::VersionedNotebookDocumentIdentifier + # @return [VersionedNotebookDocumentIdentifier] a new instance of VersionedNotebookDocumentIdentifier + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_notebook_document_identifier.rb#8 + def initialize(version:, uri:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_notebook_document_identifier.rb#33 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_notebook_document_identifier.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_notebook_document_identifier.rb#39 + def to_json(*args); end + + # The notebook document's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_notebook_document_identifier.rb#29 + def uri; end + + # The version number of this notebook document. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_notebook_document_identifier.rb#21 + def version; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/versioned_text_document_identifier.rb#4 +class LanguageServer::Protocol::Interface::VersionedTextDocumentIdentifier + # @return [VersionedTextDocumentIdentifier] a new instance of VersionedTextDocumentIdentifier + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_text_document_identifier.rb#5 + def initialize(uri:, version:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_text_document_identifier.rb#33 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_text_document_identifier.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_text_document_identifier.rb#39 + def to_json(*args); end + + # The text document's URI. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_text_document_identifier.rb#18 + def uri; end + + # The version number of this document. + # + # The version number of a document will increase after each change, + # including undo/redo. The number doesn't need to be consecutive. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/versioned_text_document_identifier.rb#29 + def version; end +end + +# The parameters send in a will save text document notification. +# +# source://language_server-protocol//lib/language_server/protocol/interface/will_save_text_document_params.rb#7 +class LanguageServer::Protocol::Interface::WillSaveTextDocumentParams + # @return [WillSaveTextDocumentParams] a new instance of WillSaveTextDocumentParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/will_save_text_document_params.rb#8 + def initialize(text_document:, reason:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/will_save_text_document_params.rb#33 + def attributes; end + + # The 'TextDocumentSaveReason'. + # + # @return [TextDocumentSaveReason] + # + # source://language_server-protocol//lib/language_server/protocol/interface/will_save_text_document_params.rb#29 + def reason; end + + # The document that will be saved. + # + # @return [TextDocumentIdentifier] + # + # source://language_server-protocol//lib/language_server/protocol/interface/will_save_text_document_params.rb#21 + def text_document; end + + # source://language_server-protocol//lib/language_server/protocol/interface/will_save_text_document_params.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/will_save_text_document_params.rb#39 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#4 +class LanguageServer::Protocol::Interface::WorkDoneProgressBegin + # @return [WorkDoneProgressBegin] a new instance of WorkDoneProgressBegin + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#5 + def initialize(kind:, title:, cancellable: T.unsafe(nil), message: T.unsafe(nil), percentage: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#68 + def attributes; end + + # Controls if a cancel button should show to allow the user to cancel the + # long running operation. Clients that don't support cancellation are + # allowed to ignore the setting. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#39 + def cancellable; end + + # @return ["begin"] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#18 + def kind; end + + # Optional, more detailed associated progress message. Contains + # complementary information to the `title`. + # + # Examples: "3/25 files", "project/src/module2", "node_modules/some_dep". + # If unset, the previous progress message (if any) is still valid. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#51 + def message; end + + # Optional progress percentage to display (value 100 is considered 100%). + # If not provided infinite progress is assumed and clients are allowed + # to ignore the `percentage` value in subsequent in report notifications. + # + # The value should be steadily rising. Clients are free to ignore values + # that are not following this rule. The value range is [0, 100] + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#64 + def percentage; end + + # Mandatory title of the progress operation. Used to briefly inform about + # the kind of operation being performed. + # + # Examples: "Indexing" or "Linking dependencies". + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#29 + def title; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#70 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_begin.rb#74 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_cancel_params.rb#4 +class LanguageServer::Protocol::Interface::WorkDoneProgressCancelParams + # @return [WorkDoneProgressCancelParams] a new instance of WorkDoneProgressCancelParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_cancel_params.rb#5 + def initialize(token:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_cancel_params.rb#21 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_cancel_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_cancel_params.rb#27 + def to_json(*args); end + + # The token to be used to report progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_cancel_params.rb#17 + def token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_create_params.rb#4 +class LanguageServer::Protocol::Interface::WorkDoneProgressCreateParams + # @return [WorkDoneProgressCreateParams] a new instance of WorkDoneProgressCreateParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_create_params.rb#5 + def initialize(token:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_create_params.rb#21 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_create_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_create_params.rb#27 + def to_json(*args); end + + # The token to be used to report progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_create_params.rb#17 + def token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_end.rb#4 +class LanguageServer::Protocol::Interface::WorkDoneProgressEnd + # @return [WorkDoneProgressEnd] a new instance of WorkDoneProgressEnd + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_end.rb#5 + def initialize(kind:, message: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_end.rb#28 + def attributes; end + + # @return ["end"] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_end.rb#15 + def kind; end + + # Optional, a final message indicating to for example indicate the outcome + # of the operation. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_end.rb#24 + def message; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_end.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_end.rb#34 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_options.rb#4 +class LanguageServer::Protocol::Interface::WorkDoneProgressOptions + # @return [WorkDoneProgressOptions] a new instance of WorkDoneProgressOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_options.rb#18 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_options.rb#20 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_options.rb#24 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_options.rb#14 + def work_done_progress; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_params.rb#4 +class LanguageServer::Protocol::Interface::WorkDoneProgressParams + # @return [WorkDoneProgressParams] a new instance of WorkDoneProgressParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_params.rb#5 + def initialize(work_done_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_params.rb#21 + def attributes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_params.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_params.rb#27 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_params.rb#17 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#4 +class LanguageServer::Protocol::Interface::WorkDoneProgressReport + # @return [WorkDoneProgressReport] a new instance of WorkDoneProgressReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#5 + def initialize(kind:, cancellable: T.unsafe(nil), message: T.unsafe(nil), percentage: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#58 + def attributes; end + + # Controls enablement state of a cancel button. This property is only valid + # if a cancel button got requested in the `WorkDoneProgressBegin` payload. + # + # Clients that don't support cancellation or don't support control the + # button's enablement state are allowed to ignore the setting. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#29 + def cancellable; end + + # @return ["report"] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#17 + def kind; end + + # Optional, more detailed associated progress message. Contains + # complementary information to the `title`. + # + # Examples: "3/25 files", "project/src/module2", "node_modules/some_dep". + # If unset, the previous progress message (if any) is still valid. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#41 + def message; end + + # Optional progress percentage to display (value 100 is considered 100%). + # If not provided infinite progress is assumed and clients are allowed + # to ignore the `percentage` value in subsequent in report notifications. + # + # The value should be steadily rising. Clients are free to ignore values + # that are not following this rule. The value range is [0, 100] + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#54 + def percentage; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#60 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/work_done_progress_report.rb#64 + def to_json(*args); end +end + +# Parameters of the workspace diagnostic request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceDiagnosticParams + # @return [WorkspaceDiagnosticParams] a new instance of WorkspaceDiagnosticParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#8 + def initialize(previous_result_ids:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil), identifier: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#53 + def attributes; end + + # The additional identifier provided during registration. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#40 + def identifier; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#32 + def partial_result_token; end + + # The currently known diagnostic reports with their + # previous result ids. + # + # @return [PreviousResultId[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#49 + def previous_result_ids; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#55 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#59 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_params.rb#23 + def work_done_token; end +end + +# A workspace diagnostic report. +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceDiagnosticReport + # @return [WorkspaceDiagnosticReport] a new instance of WorkspaceDiagnosticReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report.rb#8 + def initialize(items:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report.rb#21 + def attributes; end + + # @return [WorkspaceDocumentDiagnosticReport[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report.rb#17 + def items; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report.rb#27 + def to_json(*args); end +end + +# A partial result for a workspace diagnostic report. +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report_partial_result.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceDiagnosticReportPartialResult + # @return [WorkspaceDiagnosticReportPartialResult] a new instance of WorkspaceDiagnosticReportPartialResult + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report_partial_result.rb#8 + def initialize(items:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report_partial_result.rb#21 + def attributes; end + + # @return [WorkspaceDocumentDiagnosticReport[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report_partial_result.rb#17 + def items; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report_partial_result.rb#23 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_diagnostic_report_partial_result.rb#27 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#4 +class LanguageServer::Protocol::Interface::WorkspaceEdit + # @return [WorkspaceEdit] a new instance of WorkspaceEdit + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#5 + def initialize(changes: T.unsafe(nil), document_changes: T.unsafe(nil), change_annotations: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#56 + def attributes; end + + # A map of change annotations that can be referenced in + # `AnnotatedTextEdit`s or create, rename and delete file / folder + # operations. + # + # Whether clients honor this property depends on the client capability + # `workspace.changeAnnotationSupport`. + # + # @return [{ [id: string]: ChangeAnnotation; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#52 + def change_annotations; end + + # Holds changes to existing resources. + # + # @return [{}] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#19 + def changes; end + + # Depending on the client capability + # `workspace.workspaceEdit.resourceOperations` document changes are either + # an array of `TextDocumentEdit`s to express changes to n different text + # documents where each text document edit addresses a specific version of + # a text document. Or it can contain above `TextDocumentEdit`s mixed with + # create, rename and delete file / folder operations. + # + # Whether a client supports versioned document edits is expressed via + # `workspace.workspaceEdit.documentChanges` client capability. + # + # If a client neither supports `documentChanges` nor + # `workspace.workspaceEdit.resourceOperations` then only plain `TextEdit`s + # using the `changes` property are supported. + # + # @return [TextDocumentEdit[] | (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#39 + def document_changes; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#58 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit.rb#62 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::WorkspaceEditClientCapabilities + # @return [WorkspaceEditClientCapabilities] a new instance of WorkspaceEditClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#5 + def initialize(document_changes: T.unsafe(nil), resource_operations: T.unsafe(nil), failure_handling: T.unsafe(nil), normalizes_line_endings: T.unsafe(nil), change_annotation_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#63 + def attributes; end + + # Whether the client in general supports change annotations on text edits, + # create file, rename file and delete file changes. + # + # @return [{ groupsOnLabel?: boolean; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#59 + def change_annotation_support; end + + # The client supports versioned document changes in `WorkspaceEdit`s + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#21 + def document_changes; end + + # The failure handling strategy of a client if applying the workspace edit + # fails. + # + # @return [FailureHandlingKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#39 + def failure_handling; end + + # Whether the client normalizes line endings to the client specific + # setting. + # If set to `true` the client will normalize line ending characters + # in a workspace edit to the client specific new line character(s). + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#50 + def normalizes_line_endings; end + + # The resource operations the client supports. Clients should at least + # support 'create', 'rename' and 'delete' files and folders. + # + # @return [ResourceOperationKind[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#30 + def resource_operations; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#65 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_edit_client_capabilities.rb#69 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_folder.rb#4 +class LanguageServer::Protocol::Interface::WorkspaceFolder + # @return [WorkspaceFolder] a new instance of WorkspaceFolder + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folder.rb#5 + def initialize(uri:, name:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folder.rb#31 + def attributes; end + + # The name of the workspace folder. Used to refer to this + # workspace folder in the user interface. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folder.rb#27 + def name; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folder.rb#33 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folder.rb#37 + def to_json(*args); end + + # The associated URI for this workspace folder. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folder.rb#18 + def uri; end +end + +# The workspace folder change event. +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_change_event.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceFoldersChangeEvent + # @return [WorkspaceFoldersChangeEvent] a new instance of WorkspaceFoldersChangeEvent + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_change_event.rb#8 + def initialize(added:, removed:); end + + # The array of added workspace folders + # + # @return [WorkspaceFolder[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_change_event.rb#21 + def added; end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_change_event.rb#33 + def attributes; end + + # The array of the removed workspace folders + # + # @return [WorkspaceFolder[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_change_event.rb#29 + def removed; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_change_event.rb#35 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_change_event.rb#39 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_server_capabilities.rb#4 +class LanguageServer::Protocol::Interface::WorkspaceFoldersServerCapabilities + # @return [WorkspaceFoldersServerCapabilities] a new instance of WorkspaceFoldersServerCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_server_capabilities.rb#5 + def initialize(supported: T.unsafe(nil), change_notifications: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_server_capabilities.rb#36 + def attributes; end + + # Whether the server wants to receive workspace folder + # change notifications. + # + # If a string is provided, the string is treated as an ID + # under which the notification is registered on the client + # side. The ID can be used to unregister for these events + # using the `client/unregisterCapability` request. + # + # @return [string | boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_server_capabilities.rb#32 + def change_notifications; end + + # The server has support for workspace folders + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_server_capabilities.rb#18 + def supported; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_server_capabilities.rb#38 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_folders_server_capabilities.rb#42 + def to_json(*args); end +end + +# A full document diagnostic report for a workspace diagnostic result. +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceFullDocumentDiagnosticReport + # @return [WorkspaceFullDocumentDiagnosticReport] a new instance of WorkspaceFullDocumentDiagnosticReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#8 + def initialize(kind:, items:, uri:, version:, result_id: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#63 + def attributes; end + + # The actual items. + # + # @return [Diagnostic[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#42 + def items; end + + # A full document diagnostic report. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#24 + def kind; end + + # An optional result id. If provided it will + # be sent on the next diagnostic request for the + # same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#34 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#65 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#69 + def to_json(*args); end + + # The URI for which diagnostic information is reported. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#50 + def uri; end + + # The version number for which the diagnostics are reported. + # If the document is not marked as open `null` can be provided. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_full_document_diagnostic_report.rb#59 + def version; end +end + +# A special workspace symbol that supports locations without a range +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceSymbol + # @return [WorkspaceSymbol] a new instance of WorkspaceSymbol + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#8 + def initialize(name:, kind:, location:, tags: T.unsafe(nil), container_name: T.unsafe(nil), data: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#77 + def attributes; end + + # The name of the symbol containing this symbol. This information is for + # user interface purposes (e.g. to render a qualifier in the user interface + # if necessary). It can't be used to re-infer a hierarchy for the document + # symbols. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#52 + def container_name; end + + # A data entry field that is preserved on a workspace symbol between a + # workspace symbol request and a workspace symbol resolve request. + # + # @return [LSPAny] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#73 + def data; end + + # The kind of this symbol. + # + # @return [SymbolKind] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#33 + def kind; end + + # The location of this symbol. Whether a server is allowed to + # return a location without a range depends on the client + # capability `workspace.symbol.resolveSupport`. + # + # See also `SymbolInformation.location`. + # + # @return [Location | { uri: string; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#64 + def location; end + + # The name of this symbol. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#25 + def name; end + + # Tags for this completion item. + # + # @return [1[]] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#41 + def tags; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#79 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol.rb#83 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#4 +class LanguageServer::Protocol::Interface::WorkspaceSymbolClientCapabilities + # @return [WorkspaceSymbolClientCapabilities] a new instance of WorkspaceSymbolClientCapabilities + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#5 + def initialize(dynamic_registration: T.unsafe(nil), symbol_kind: T.unsafe(nil), tag_support: T.unsafe(nil), resolve_support: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#52 + def attributes; end + + # Symbol request supports dynamic registration. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#20 + def dynamic_registration; end + + # The client support partial workspace symbols. The client will send the + # request `workspaceSymbol/resolve` to the server to resolve additional + # properties. + # + # @return [{ properties: string[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#48 + def resolve_support; end + + # Specific capabilities for the `SymbolKind` in the `workspace/symbol` + # request. + # + # @return [{ valueSet?: SymbolKind[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#29 + def symbol_kind; end + + # The client supports tags on `SymbolInformation` and `WorkspaceSymbol`. + # Clients supporting tags have to handle unknown tags gracefully. + # + # @return [{ valueSet: 1[]; }] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#38 + def tag_support; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#54 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_client_capabilities.rb#58 + def to_json(*args); end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_options.rb#4 +class LanguageServer::Protocol::Interface::WorkspaceSymbolOptions + # @return [WorkspaceSymbolOptions] a new instance of WorkspaceSymbolOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_options.rb#28 + def attributes; end + + # The server provides support to resolve additional + # information for a workspace symbol. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_options.rb#24 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_options.rb#15 + def work_done_progress; end +end + +# The parameters of a Workspace Symbol Request. +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceSymbolParams + # @return [WorkspaceSymbolParams] a new instance of WorkspaceSymbolParams + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#8 + def initialize(query:, work_done_token: T.unsafe(nil), partial_result_token: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#44 + def attributes; end + + # An optional token that a server can use to report partial results (e.g. + # streaming) to the client. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#31 + def partial_result_token; end + + # A query string to filter symbols by. Clients may send an empty + # string here to request all symbols. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#40 + def query; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#46 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#50 + def to_json(*args); end + + # An optional token that a server can use to report work done progress. + # + # @return [ProgressToken] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_params.rb#22 + def work_done_token; end +end + +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_registration_options.rb#4 +class LanguageServer::Protocol::Interface::WorkspaceSymbolRegistrationOptions + # @return [WorkspaceSymbolRegistrationOptions] a new instance of WorkspaceSymbolRegistrationOptions + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_registration_options.rb#5 + def initialize(work_done_progress: T.unsafe(nil), resolve_provider: T.unsafe(nil)); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_registration_options.rb#28 + def attributes; end + + # The server provides support to resolve additional + # information for a workspace symbol. + # + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_registration_options.rb#24 + def resolve_provider; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_registration_options.rb#30 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_registration_options.rb#34 + def to_json(*args); end + + # @return [boolean] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_symbol_registration_options.rb#15 + def work_done_progress; end +end + +# An unchanged document diagnostic report for a workspace diagnostic result. +# +# source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#7 +class LanguageServer::Protocol::Interface::WorkspaceUnchangedDocumentDiagnosticReport + # @return [WorkspaceUnchangedDocumentDiagnosticReport] a new instance of WorkspaceUnchangedDocumentDiagnosticReport + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#8 + def initialize(kind:, result_id:, uri:, version:); end + + # Returns the value of attribute attributes. + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#56 + def attributes; end + + # A document diagnostic report indicating + # no changes to the last result. A server can + # only return `unchanged` if result ids are + # provided. + # + # @return [any] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#26 + def kind; end + + # A result id which will be sent on the next + # diagnostic request for the same document. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#35 + def result_id; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#58 + def to_hash; end + + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#62 + def to_json(*args); end + + # The URI for which diagnostic information is reported. + # + # @return [string] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#43 + def uri; end + + # The version number for which the diagnostics are reported. + # If the document is not marked as open `null` can be provided. + # + # @return [number] + # + # source://language_server-protocol//lib/language_server/protocol/interface/workspace_unchanged_document_diagnostic_report.rb#52 + def version; end +end + +# source://language_server-protocol//lib/language_server/protocol/transport/io/reader.rb#7 +module LanguageServer::Protocol::Transport; end + +# source://language_server-protocol//lib/language_server/protocol/transport/io/reader.rb#8 +module LanguageServer::Protocol::Transport::Io; end + +# source://language_server-protocol//lib/language_server/protocol/transport/io/reader.rb#9 +class LanguageServer::Protocol::Transport::Io::Reader + # @return [Reader] a new instance of Reader + # + # source://language_server-protocol//lib/language_server/protocol/transport/io/reader.rb#10 + def initialize(io); end + + # source://language_server-protocol//lib/language_server/protocol/transport/io/reader.rb#15 + def read(&block); end + + private + + # Returns the value of attribute io. + # + # source://language_server-protocol//lib/language_server/protocol/transport/io/reader.rb#26 + def io; end +end + +# source://language_server-protocol//lib/language_server/protocol/transport/io/writer.rb#5 +class LanguageServer::Protocol::Transport::Io::Writer + # @return [Writer] a new instance of Writer + # + # source://language_server-protocol//lib/language_server/protocol/transport/io/writer.rb#8 + def initialize(io); end + + # Returns the value of attribute io. + # + # source://language_server-protocol//lib/language_server/protocol/transport/io/writer.rb#6 + def io; end + + # source://language_server-protocol//lib/language_server/protocol/transport/io/writer.rb#13 + def write(response); end +end + +# source://language_server-protocol//lib/language_server/protocol/transport/stdio/reader.rb#4 +module LanguageServer::Protocol::Transport::Stdio; end + +# source://language_server-protocol//lib/language_server/protocol/transport/stdio/reader.rb#5 +class LanguageServer::Protocol::Transport::Stdio::Reader < ::LanguageServer::Protocol::Transport::Io::Reader + # @return [Reader] a new instance of Reader + # + # source://language_server-protocol//lib/language_server/protocol/transport/stdio/reader.rb#6 + def initialize; end +end + +# source://language_server-protocol//lib/language_server/protocol/transport/stdio/writer.rb#5 +class LanguageServer::Protocol::Transport::Stdio::Writer < ::LanguageServer::Protocol::Transport::Io::Writer + # @return [Writer] a new instance of Writer + # + # source://language_server-protocol//lib/language_server/protocol/transport/stdio/writer.rb#6 + def initialize; end +end + +# source://language_server-protocol//lib/language_server/protocol/version.rb#3 +LanguageServer::Protocol::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/minitest-reporters@1.4.3.rbi b/sorbet/rbi/gems/minitest-reporters@1.6.0.rbi similarity index 96% rename from sorbet/rbi/gems/minitest-reporters@1.4.3.rbi rename to sorbet/rbi/gems/minitest-reporters@1.6.0.rbi index 355555fa..bcc1b1db 100644 --- a/sorbet/rbi/gems/minitest-reporters@1.4.3.rbi +++ b/sorbet/rbi/gems/minitest-reporters@1.6.0.rbi @@ -401,7 +401,7 @@ end # The report is generated using ERB. A custom ERB template can be provided but it is not required # The default ERB template uses JQuery and Bootstrap, both of these are included by referencing the CDN sites # -# source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#21 +# source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#20 class Minitest::Reporters::HtmlReporter < ::Minitest::Reporters::BaseReporter # The constructor takes a hash, and uses the following keys: # :title - the title that will be used in the report, defaults to 'Test Results' @@ -412,12 +412,12 @@ class Minitest::Reporters::HtmlReporter < ::Minitest::Reporters::BaseReporter # # @return [HtmlReporter] a new instance of HtmlReporter # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#57 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#60 def initialize(args = T.unsafe(nil)); end # Trims off the number prefix on test names when using Minitest Specs # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#45 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#48 def friendly_name(test); end # The number of tests that passed @@ -427,7 +427,7 @@ class Minitest::Reporters::HtmlReporter < ::Minitest::Reporters::BaseReporter # The percentage of tests that failed # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#40 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#43 def percent_errors_failures; end # The percentage of tests that passed, calculated in a way that avoids rounding errors @@ -436,16 +436,22 @@ class Minitest::Reporters::HtmlReporter < ::Minitest::Reporters::BaseReporter def percent_passes; end # The percentage of tests that were skipped + # Keeping old method name with typo for backwards compatibility in custom templates (for now) # # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#35 def percent_skipps; end + # The percentage of tests that were skipped + # + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#35 + def percent_skips; end + # Called by the framework to generate the report # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#88 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#91 def report; end - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#79 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#82 def start; end # The title of the report @@ -459,46 +465,46 @@ class Minitest::Reporters::HtmlReporter < ::Minitest::Reporters::BaseReporter # Test suites which have failing tests are given highest order # Tests suites which have skipped tests are given second highest priority # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#139 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#142 def compare_suites(suite_a, suite_b); end - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#128 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#131 def compare_suites_by_name(suite_a, suite_b); end # Tests are first ordered by evaluating the results of the tests, then by tests names # Tess which fail are given highest order # Tests which are skipped are given second highest priority # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#154 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#157 def compare_tests(test_a, test_b); end - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#132 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#135 def compare_tests_by_name(test_a, test_b); end - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#124 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#127 def html_file; end # taken from the JUnit reporter # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#204 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#207 def location(exception); end # based on message_for(test) from the JUnit reporter # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#187 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#190 def message_for(test); end # based on analyze_suite from the JUnit reporter # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#172 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#175 def summarize_suite(suite, tests); end # @return [Boolean] # - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#167 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#170 def test_fail_or_error?(test); end - # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#213 + # source://minitest-reporters//lib/minitest/reporters/html_reporter.rb#216 def total_time_to_hms; end end @@ -509,49 +515,49 @@ end # Also inspired by Marc Seeger's attempt at producing a JUnitReporter (see https://github.com/rb2k/minitest-reporters/commit/e13d95b5f884453a9c77f62bc5cba3fa1df30ef5) # Also inspired by minitest-ci (see https://github.com/bhenderson/minitest-ci) # -# source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#14 +# source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#16 class Minitest::Reporters::JUnitReporter < ::Minitest::Reporters::BaseReporter # @return [JUnitReporter] a new instance of JUnitReporter # - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#19 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#21 def initialize(reports_dir = T.unsafe(nil), empty = T.unsafe(nil), options = T.unsafe(nil)); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#61 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#64 def get_relative_path(result); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#32 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#35 def report; end # Returns the value of attribute reports_path. # - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#17 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#19 def reports_path; end private - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#149 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#168 def analyze_suite(tests); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#161 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#181 def filename_for(suite); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#74 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#77 def get_source_location(result); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#139 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#158 def location(exception); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#123 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#142 def message_for(test); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#82 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#85 def parse_xml_for(xml, suite, tests); end - # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#100 + # source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#119 def xml_message_for(test); end end -# source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#15 +# source://minitest-reporters//lib/minitest/reporters/junit_reporter.rb#17 Minitest::Reporters::JUnitReporter::DEFAULT_REPORTS_DIR = T.let(T.unsafe(nil), String) # This reporter creates a report providing the average (mean), minimum and @@ -928,27 +934,39 @@ class Minitest::Reporters::SpecReporter < ::Minitest::Reporters::BaseReporter include ::Minitest::Reporters::ANSI::Code include ::Minitest::RelativePosition - # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#29 + # The constructor takes an `options` hash + # + # @option options + # @param options [Hash] + # @return [SpecReporter] a new instance of SpecReporter + # + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#18 + def initialize(options = T.unsafe(nil)); end + + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#50 def record(test); end - # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#19 + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#29 def report; end - # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#13 + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#23 def start; end protected - # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#41 + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#62 def after_suite(_suite); end - # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#37 + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#58 def before_suite(suite); end - # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#53 + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#66 + def print_failure(name, tests); end + + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#76 def record_print_failures_if_any(test); end - # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#45 + # source://minitest-reporters//lib/minitest/reporters/spec_reporter.rb#83 def record_print_status(test); end end diff --git a/sorbet/rbi/gems/minitest@5.18.0.rbi b/sorbet/rbi/gems/minitest@5.18.1.rbi similarity index 86% rename from sorbet/rbi/gems/minitest@5.18.0.rbi rename to sorbet/rbi/gems/minitest@5.18.1.rbi index 32a82630..f68a238d 100644 --- a/sorbet/rbi/gems/minitest@5.18.0.rbi +++ b/sorbet/rbi/gems/minitest@5.18.1.rbi @@ -37,7 +37,7 @@ module Minitest # source://minitest//lib/minitest.rb#18 def cattr_accessor(name); end - # source://minitest//lib/minitest.rb#1059 + # source://minitest//lib/minitest.rb#1073 def clock_time; end # source://minitest//lib/minitest.rb#19 @@ -95,7 +95,7 @@ module Minitest # source://minitest//lib/minitest.rb#140 def run(args = T.unsafe(nil)); end - # source://minitest//lib/minitest.rb#1050 + # source://minitest//lib/minitest.rb#1064 def run_one_method(klass, method_name); end # source://minitest//lib/minitest.rb#19 @@ -109,27 +109,27 @@ end # Defines the API for Reporters. Subclass this and override whatever # you want. Go nuts. # -# source://minitest//lib/minitest.rb#578 +# source://minitest//lib/minitest.rb#592 class Minitest::AbstractReporter include ::Mutex_m - # source://mutex_m/0.1.1/mutex_m.rb#93 + # source://mutex_m/0.1.2/mutex_m.rb#93 def lock; end - # source://mutex_m/0.1.1/mutex_m.rb#83 + # source://mutex_m/0.1.2/mutex_m.rb#83 def locked?; end # Did this run pass? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#612 + # source://minitest//lib/minitest.rb#626 def passed?; end # About to start running a test. This allows a reporter to show # that it is starting or that we are in the middle of a test run. # - # source://minitest//lib/minitest.rb#591 + # source://minitest//lib/minitest.rb#605 def prerecord(klass, name); end # Output and record the result of the test. Call @@ -137,45 +137,45 @@ class Minitest::AbstractReporter # result character string. Stores the result of the run if the run # did not pass. # - # source://minitest//lib/minitest.rb#600 + # source://minitest//lib/minitest.rb#614 def record(result); end # Outputs the summary of the run. # - # source://minitest//lib/minitest.rb#606 + # source://minitest//lib/minitest.rb#620 def report; end # Starts reporting on the run. # - # source://minitest//lib/minitest.rb#584 + # source://minitest//lib/minitest.rb#598 def start; end - # source://mutex_m/0.1.1/mutex_m.rb#78 + # source://mutex_m/0.1.2/mutex_m.rb#78 def synchronize(&block); end - # source://mutex_m/0.1.1/mutex_m.rb#88 + # source://mutex_m/0.1.2/mutex_m.rb#88 def try_lock; end - # source://mutex_m/0.1.1/mutex_m.rb#98 + # source://mutex_m/0.1.2/mutex_m.rb#98 def unlock; end end # Represents run failures. # -# source://minitest//lib/minitest.rb#895 +# source://minitest//lib/minitest.rb#909 class Minitest::Assertion < ::Exception - # source://minitest//lib/minitest.rb#896 + # source://minitest//lib/minitest.rb#910 def error; end # Where was this run before an assertion was raised? # - # source://minitest//lib/minitest.rb#903 + # source://minitest//lib/minitest.rb#917 def location; end - # source://minitest//lib/minitest.rb#912 + # source://minitest//lib/minitest.rb#926 def result_code; end - # source://minitest//lib/minitest.rb#916 + # source://minitest//lib/minitest.rb#930 def result_label; end end @@ -618,60 +618,60 @@ Minitest::Assertions::UNDEFINED = T.let(T.unsafe(nil), Object) # # See Minitest.backtrace_filter=. # -# source://minitest//lib/minitest.rb#1027 +# source://minitest//lib/minitest.rb#1041 class Minitest::BacktraceFilter # Filter +bt+ to something useful. Returns the whole thing if # $DEBUG (ruby) or $MT_DEBUG (env). # - # source://minitest//lib/minitest.rb#1035 + # source://minitest//lib/minitest.rb#1049 def filter(bt); end end -# source://minitest//lib/minitest.rb#1029 +# source://minitest//lib/minitest.rb#1043 Minitest::BacktraceFilter::MT_RE = T.let(T.unsafe(nil), Regexp) # Dispatch to multiple reporters as one. # -# source://minitest//lib/minitest.rb#846 +# source://minitest//lib/minitest.rb#858 class Minitest::CompositeReporter < ::Minitest::AbstractReporter # @return [CompositeReporter] a new instance of CompositeReporter # - # source://minitest//lib/minitest.rb#850 + # source://minitest//lib/minitest.rb#864 def initialize(*reporters); end # Add another reporter to the mix. # - # source://minitest//lib/minitest.rb#862 + # source://minitest//lib/minitest.rb#876 def <<(reporter); end - # source://minitest//lib/minitest.rb#855 + # source://minitest//lib/minitest.rb#869 def io; end # @return [Boolean] # - # source://minitest//lib/minitest.rb#866 + # source://minitest//lib/minitest.rb#880 def passed?; end - # source://minitest//lib/minitest.rb#874 + # source://minitest//lib/minitest.rb#888 def prerecord(klass, name); end - # source://minitest//lib/minitest.rb#881 + # source://minitest//lib/minitest.rb#895 def record(result); end - # source://minitest//lib/minitest.rb#887 + # source://minitest//lib/minitest.rb#901 def report; end # The list of reporters to dispatch to. # - # source://minitest//lib/minitest.rb#848 + # source://minitest//lib/minitest.rb#862 def reporters; end # The list of reporters to dispatch to. # - # source://minitest//lib/minitest.rb#848 + # source://minitest//lib/minitest.rb#862 def reporters=(_arg0); end - # source://minitest//lib/minitest.rb#870 + # source://minitest//lib/minitest.rb#884 def start; end end @@ -689,48 +689,48 @@ end # # ... lots of test methods ... # end # -# source://minitest//lib/minitest.rb#971 +# source://minitest//lib/minitest.rb#985 module Minitest::Guard # Is this running on jruby? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#976 + # source://minitest//lib/minitest.rb#990 def jruby?(platform = T.unsafe(nil)); end # Is this running on maglev? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#983 + # source://minitest//lib/minitest.rb#997 def maglev?(platform = T.unsafe(nil)); end # Is this running on mri? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#993 + # source://minitest//lib/minitest.rb#1007 def mri?(platform = T.unsafe(nil)); end # Is this running on macOS? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#1000 + # source://minitest//lib/minitest.rb#1014 def osx?(platform = T.unsafe(nil)); end # Is this running on rubinius? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#1007 + # source://minitest//lib/minitest.rb#1021 def rubinius?(platform = T.unsafe(nil)); end # Is this running on windows? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#1017 + # source://minitest//lib/minitest.rb#1031 def windows?(platform = T.unsafe(nil)); end end @@ -793,36 +793,36 @@ end # plugin, pull this out of the composite and replace it with your # own. # -# source://minitest//lib/minitest.rb#643 +# source://minitest//lib/minitest.rb#657 class Minitest::ProgressReporter < ::Minitest::Reporter - # source://minitest//lib/minitest.rb#644 + # source://minitest//lib/minitest.rb#658 def prerecord(klass, name); end - # source://minitest//lib/minitest.rb#651 + # source://minitest//lib/minitest.rb#665 def record(result); end end # Shared code for anything that can get passed to a Reporter. See # Minitest::Test & Minitest::Result. # -# source://minitest//lib/minitest.rb#475 +# source://minitest//lib/minitest.rb#489 module Minitest::Reportable # @raise [NotImplementedError] # - # source://minitest//lib/minitest.rb#495 + # source://minitest//lib/minitest.rb#509 def class_name; end # Did this run error? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#516 + # source://minitest//lib/minitest.rb#530 def error?; end # The location identifier of this test. Depends on a method # existing called class_name. # - # source://minitest//lib/minitest.rb#490 + # source://minitest//lib/minitest.rb#504 def location; end # Did this run pass? @@ -832,47 +832,47 @@ module Minitest::Reportable # # @return [Boolean] # - # source://minitest//lib/minitest.rb#482 + # source://minitest//lib/minitest.rb#496 def passed?; end # Returns ".", "F", or "E" based on the result of the run. # - # source://minitest//lib/minitest.rb#502 + # source://minitest//lib/minitest.rb#516 def result_code; end # Was this run skipped? # # @return [Boolean] # - # source://minitest//lib/minitest.rb#509 + # source://minitest//lib/minitest.rb#523 def skipped?; end end -# source://minitest//lib/minitest.rb#619 +# source://minitest//lib/minitest.rb#633 class Minitest::Reporter < ::Minitest::AbstractReporter # @return [Reporter] a new instance of Reporter # - # source://minitest//lib/minitest.rb#628 + # source://minitest//lib/minitest.rb#642 def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end # The IO used to report. # - # source://minitest//lib/minitest.rb#621 + # source://minitest//lib/minitest.rb#635 def io; end # The IO used to report. # - # source://minitest//lib/minitest.rb#621 + # source://minitest//lib/minitest.rb#635 def io=(_arg0); end # Command-line options for this run. # - # source://minitest//lib/minitest.rb#626 + # source://minitest//lib/minitest.rb#640 def options; end # Command-line options for this run. # - # source://minitest//lib/minitest.rb#626 + # source://minitest//lib/minitest.rb#640 def options=(_arg0); end end @@ -882,40 +882,40 @@ end # blow up. By using Result.from(a_test) you can be reasonably sure # that the test result can be marshalled. # -# source://minitest//lib/minitest.rb#528 +# source://minitest//lib/minitest.rb#542 class Minitest::Result < ::Minitest::Runnable include ::Minitest::Reportable - # source://minitest//lib/minitest.rb#561 + # source://minitest//lib/minitest.rb#575 def class_name; end # The class name of the test result. # - # source://minitest//lib/minitest.rb#537 + # source://minitest//lib/minitest.rb#551 def klass; end # The class name of the test result. # - # source://minitest//lib/minitest.rb#537 + # source://minitest//lib/minitest.rb#551 def klass=(_arg0); end # The location of the test method. # - # source://minitest//lib/minitest.rb#542 + # source://minitest//lib/minitest.rb#556 def source_location; end # The location of the test method. # - # source://minitest//lib/minitest.rb#542 + # source://minitest//lib/minitest.rb#556 def source_location=(_arg0); end - # source://minitest//lib/minitest.rb#565 + # source://minitest//lib/minitest.rb#579 def to_s; end class << self # Create a new test result from a Runnable instance. # - # source://minitest//lib/minitest.rb#547 + # source://minitest//lib/minitest.rb#561 def from(runnable); end end end @@ -926,7 +926,7 @@ end class Minitest::Runnable # @return [Runnable] a new instance of Runnable # - # source://minitest//lib/minitest.rb#431 + # source://minitest//lib/minitest.rb#445 def initialize(name); end # Number of assertions executed in this run. @@ -939,7 +939,7 @@ class Minitest::Runnable # source://minitest//lib/minitest.rb#281 def assertions=(_arg0); end - # source://minitest//lib/minitest.rb#427 + # source://minitest//lib/minitest.rb#441 def failure; end # An assertion raised during the run, if any. @@ -952,10 +952,10 @@ class Minitest::Runnable # source://minitest//lib/minitest.rb#286 def failures=(_arg0); end - # source://minitest//lib/minitest.rb#413 + # source://minitest//lib/minitest.rb#427 def marshal_dump; end - # source://minitest//lib/minitest.rb#423 + # source://minitest//lib/minitest.rb#437 def marshal_load(ary); end # Name of the run. @@ -976,7 +976,7 @@ class Minitest::Runnable # @raise [NotImplementedError] # @return [Boolean] # - # source://minitest//lib/minitest.rb#450 + # source://minitest//lib/minitest.rb#464 def passed?; end # Returns a single character string to print based on the result @@ -985,14 +985,14 @@ class Minitest::Runnable # # @raise [NotImplementedError] # - # source://minitest//lib/minitest.rb#459 + # source://minitest//lib/minitest.rb#473 def result_code; end # Runs a single method. Needs to return self. # # @raise [NotImplementedError] # - # source://minitest//lib/minitest.rb#440 + # source://minitest//lib/minitest.rb#454 def run; end # Was this run skipped? See #passed? for more information. @@ -1000,7 +1000,7 @@ class Minitest::Runnable # @raise [NotImplementedError] # @return [Boolean] # - # source://minitest//lib/minitest.rb#466 + # source://minitest//lib/minitest.rb#480 def skipped?; end # The time it took to run. @@ -1017,7 +1017,7 @@ class Minitest::Runnable def time_it; end class << self - # source://minitest//lib/minitest.rb#1069 + # source://minitest//lib/minitest.rb#1083 def inherited(klass); end # Returns all instance methods matching the pattern +re+. @@ -1025,7 +1025,7 @@ class Minitest::Runnable # source://minitest//lib/minitest.rb#318 def methods_matching(re); end - # source://minitest//lib/minitest.rb#383 + # source://minitest//lib/minitest.rb#397 def on_signal(name, action); end # source://minitest//lib/minitest.rb#322 @@ -1043,7 +1043,7 @@ class Minitest::Runnable # that subclasses can specialize the running of an individual # test. See Minitest::ParallelTest::ClassMethods for an example. # - # source://minitest//lib/minitest.rb#363 + # source://minitest//lib/minitest.rb#369 def run_one_method(klass, method_name, reporter); end # Each subclass of Runnable is responsible for overriding this @@ -1051,27 +1051,33 @@ class Minitest::Runnable # # @raise [NotImplementedError] # - # source://minitest//lib/minitest.rb#400 + # source://minitest//lib/minitest.rb#414 def runnable_methods; end # Returns all subclasses of Runnable. # - # source://minitest//lib/minitest.rb#407 + # source://minitest//lib/minitest.rb#421 def runnables; end - # source://minitest//lib/minitest.rb#368 + # Defines the order to run tests (:random by default). Override + # this or use a convenience method to change it for your tests. + # + # source://minitest//lib/minitest.rb#378 + def test_order; end + + # source://minitest//lib/minitest.rb#382 def with_info_handler(reporter, &block); end end end -# source://minitest//lib/minitest.rb#381 +# source://minitest//lib/minitest.rb#395 Minitest::Runnable::SIGNALS = T.let(T.unsafe(nil), Hash) # Assertion raised when skipping a run. # -# source://minitest//lib/minitest.rb#924 +# source://minitest//lib/minitest.rb#938 class Minitest::Skip < ::Minitest::Assertion - # source://minitest//lib/minitest.rb#925 + # source://minitest//lib/minitest.rb#939 def result_label; end end @@ -1095,113 +1101,113 @@ end # end # end # -# source://minitest//lib/minitest.rb#681 +# source://minitest//lib/minitest.rb#693 class Minitest::StatisticsReporter < ::Minitest::Reporter # @return [StatisticsReporter] a new instance of StatisticsReporter # - # source://minitest//lib/minitest.rb#723 + # source://minitest//lib/minitest.rb#737 def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end # Total number of assertions. # - # source://minitest//lib/minitest.rb#683 + # source://minitest//lib/minitest.rb#697 def assertions; end # Total number of assertions. # - # source://minitest//lib/minitest.rb#683 + # source://minitest//lib/minitest.rb#697 def assertions=(_arg0); end # Total number of test cases. # - # source://minitest//lib/minitest.rb#688 + # source://minitest//lib/minitest.rb#702 def count; end # Total number of test cases. # - # source://minitest//lib/minitest.rb#688 + # source://minitest//lib/minitest.rb#702 def count=(_arg0); end # Total number of tests that erred. # - # source://minitest//lib/minitest.rb#716 + # source://minitest//lib/minitest.rb#730 def errors; end # Total number of tests that erred. # - # source://minitest//lib/minitest.rb#716 + # source://minitest//lib/minitest.rb#730 def errors=(_arg0); end # Total number of tests that failed. # - # source://minitest//lib/minitest.rb#711 + # source://minitest//lib/minitest.rb#725 def failures; end # Total number of tests that failed. # - # source://minitest//lib/minitest.rb#711 + # source://minitest//lib/minitest.rb#725 def failures=(_arg0); end # @return [Boolean] # - # source://minitest//lib/minitest.rb#736 + # source://minitest//lib/minitest.rb#750 def passed?; end - # source://minitest//lib/minitest.rb#744 + # source://minitest//lib/minitest.rb#758 def record(result); end # Report on the tracked statistics. # - # source://minitest//lib/minitest.rb#754 + # source://minitest//lib/minitest.rb#768 def report; end # An +Array+ of test cases that failed or were skipped. # - # source://minitest//lib/minitest.rb#693 + # source://minitest//lib/minitest.rb#707 def results; end # An +Array+ of test cases that failed or were skipped. # - # source://minitest//lib/minitest.rb#693 + # source://minitest//lib/minitest.rb#707 def results=(_arg0); end # Total number of tests that where skipped. # - # source://minitest//lib/minitest.rb#721 + # source://minitest//lib/minitest.rb#735 def skips; end # Total number of tests that where skipped. # - # source://minitest//lib/minitest.rb#721 + # source://minitest//lib/minitest.rb#735 def skips=(_arg0); end - # source://minitest//lib/minitest.rb#740 + # source://minitest//lib/minitest.rb#754 def start; end # Time the test run started. If available, the monotonic clock is # used and this is a +Float+, otherwise it's an instance of # +Time+. # - # source://minitest//lib/minitest.rb#700 + # source://minitest//lib/minitest.rb#714 def start_time; end # Time the test run started. If available, the monotonic clock is # used and this is a +Float+, otherwise it's an instance of # +Time+. # - # source://minitest//lib/minitest.rb#700 + # source://minitest//lib/minitest.rb#714 def start_time=(_arg0); end # Test run time. If available, the monotonic clock is used and # this is a +Float+, otherwise it's an instance of +Time+. # - # source://minitest//lib/minitest.rb#706 + # source://minitest//lib/minitest.rb#720 def total_time; end # Test run time. If available, the monotonic clock is used and # this is a +Float+, otherwise it's an instance of +Time+. # - # source://minitest//lib/minitest.rb#706 + # source://minitest//lib/minitest.rb#720 def total_time=(_arg0); end end @@ -1213,48 +1219,48 @@ end # plugin, pull this out of the composite and replace it with your # own. # -# source://minitest//lib/minitest.rb#775 +# source://minitest//lib/minitest.rb#788 class Minitest::SummaryReporter < ::Minitest::StatisticsReporter - # source://minitest//lib/minitest.rb#809 + # source://minitest//lib/minitest.rb#823 def aggregated_results(io); end # Returns the value of attribute old_sync. # - # source://minitest//lib/minitest.rb#777 + # source://minitest//lib/minitest.rb#791 def old_sync; end # Sets the attribute old_sync # # @param value the value to set the attribute old_sync to. # - # source://minitest//lib/minitest.rb#777 + # source://minitest//lib/minitest.rb#791 def old_sync=(_arg0); end - # source://minitest//lib/minitest.rb#792 + # source://minitest//lib/minitest.rb#806 def report; end # :startdoc: # - # source://minitest//lib/minitest.rb#780 + # source://minitest//lib/minitest.rb#794 def start; end - # source://minitest//lib/minitest.rb#804 + # source://minitest//lib/minitest.rb#818 def statistics; end - # source://minitest//lib/minitest.rb#829 + # source://minitest//lib/minitest.rb#843 def summary; end # :stopdoc: # - # source://minitest//lib/minitest.rb#776 + # source://minitest//lib/minitest.rb#790 def sync; end # :stopdoc: # - # source://minitest//lib/minitest.rb#776 + # source://minitest//lib/minitest.rb#790 def sync=(_arg0); end - # source://minitest//lib/minitest.rb#825 + # source://minitest//lib/minitest.rb#839 def to_s; end end @@ -1273,27 +1279,27 @@ class Minitest::Test < ::Minitest::Runnable # LifecycleHooks # - # source://minitest//lib/minitest/test.rb#198 + # source://minitest//lib/minitest/test.rb#190 def capture_exceptions; end # source://minitest//lib/minitest/test.rb#15 def class_name; end - # source://minitest//lib/minitest/test.rb#215 + # source://minitest//lib/minitest/test.rb#207 def neuter_exception(e); end - # source://minitest//lib/minitest/test.rb#226 + # source://minitest//lib/minitest/test.rb#218 def new_exception(klass, msg, bt, kill = T.unsafe(nil)); end # Runs a single test with setup/teardown hooks. # - # source://minitest//lib/minitest/test.rb#94 + # source://minitest//lib/minitest/test.rb#86 def run; end - # source://minitest//lib/minitest/test.rb#208 + # source://minitest//lib/minitest/test.rb#200 def sanitize_exception(e); end - # source://minitest//lib/minitest/test.rb#240 + # source://minitest//lib/minitest/test.rb#232 def with_info_handler(&block); end class << self @@ -1337,12 +1343,6 @@ class Minitest::Test < ::Minitest::Runnable # # source://minitest//lib/minitest/test.rb#69 def runnable_methods; end - - # Defines the order to run tests (:random by default). Override - # this or use a convenience method to change it for your tests. - # - # source://minitest//lib/minitest/test.rb#87 - def test_order; end end end @@ -1350,7 +1350,7 @@ end # meant for library writers, NOT for regular test authors. See # #before_setup for an example. # -# source://minitest//lib/minitest/test.rb#121 +# source://minitest//lib/minitest/test.rb#113 module Minitest::Test::LifecycleHooks # Runs before every test, after setup. This hook is meant for # libraries to extend minitest. It is not meant to be used by @@ -1358,7 +1358,7 @@ module Minitest::Test::LifecycleHooks # # See #before_setup for an example. # - # source://minitest//lib/minitest/test.rb#171 + # source://minitest//lib/minitest/test.rb#163 def after_setup; end # Runs after every test, after teardown. This hook is meant for @@ -1367,7 +1367,7 @@ module Minitest::Test::LifecycleHooks # # See #before_setup for an example. # - # source://minitest//lib/minitest/test.rb#195 + # source://minitest//lib/minitest/test.rb#187 def after_teardown; end # Runs before every test, before setup. This hook is meant for @@ -1402,7 +1402,7 @@ module Minitest::Test::LifecycleHooks # include MyMinitestPlugin # end # - # source://minitest//lib/minitest/test.rb#156 + # source://minitest//lib/minitest/test.rb#148 def before_setup; end # Runs after every test, before teardown. This hook is meant for @@ -1411,19 +1411,19 @@ module Minitest::Test::LifecycleHooks # # See #before_setup for an example. # - # source://minitest//lib/minitest/test.rb#180 + # source://minitest//lib/minitest/test.rb#172 def before_teardown; end # Runs before every test. Use this to set up before each test # run. # - # source://minitest//lib/minitest/test.rb#162 + # source://minitest//lib/minitest/test.rb#154 def setup; end # Runs after every test. Use this to clean up after each test # run. # - # source://minitest//lib/minitest/test.rb#186 + # source://minitest//lib/minitest/test.rb#178 def teardown; end end @@ -1438,30 +1438,30 @@ Minitest::Test::TEARDOWN_METHODS = T.let(T.unsafe(nil), Array) # Assertion wrapping an unexpected error that was raised during a run. # -# source://minitest//lib/minitest.rb#934 +# source://minitest//lib/minitest.rb#947 class Minitest::UnexpectedError < ::Minitest::Assertion # @return [UnexpectedError] a new instance of UnexpectedError # - # source://minitest//lib/minitest.rb#937 + # source://minitest//lib/minitest.rb#951 def initialize(error); end - # source://minitest//lib/minitest.rb#942 + # source://minitest//lib/minitest.rb#956 def backtrace; end # TODO: figure out how to use `cause` instead # - # source://minitest//lib/minitest.rb#935 + # source://minitest//lib/minitest.rb#949 def error; end # TODO: figure out how to use `cause` instead # - # source://minitest//lib/minitest.rb#935 + # source://minitest//lib/minitest.rb#949 def error=(_arg0); end - # source://minitest//lib/minitest.rb#946 + # source://minitest//lib/minitest.rb#960 def message; end - # source://minitest//lib/minitest.rb#951 + # source://minitest//lib/minitest.rb#965 def result_label; end end diff --git a/sorbet/rbi/gems/parallel@1.22.1.rbi b/sorbet/rbi/gems/parallel@1.23.0.rbi similarity index 59% rename from sorbet/rbi/gems/parallel@1.22.1.rbi rename to sorbet/rbi/gems/parallel@1.23.0.rbi index a8633dfd..c8b319a3 100644 --- a/sorbet/rbi/gems/parallel@1.22.1.rbi +++ b/sorbet/rbi/gems/parallel@1.23.0.rbi @@ -6,216 +6,212 @@ # source://parallel//lib/parallel/version.rb#2 module Parallel - extend ::Parallel::ProcessorCount - class << self # @return [Boolean] # - # source://parallel//lib/parallel.rb#246 + # source://parallel//lib/parallel.rb#243 def all?(*args, &block); end # @return [Boolean] # - # source://parallel//lib/parallel.rb#241 + # source://parallel//lib/parallel.rb#238 def any?(*args, &block); end - # source://parallel//lib/parallel.rb#237 + # source://parallel//lib/parallel.rb#234 def each(array, options = T.unsafe(nil), &block); end - # source://parallel//lib/parallel.rb#251 + # source://parallel//lib/parallel.rb#248 def each_with_index(array, options = T.unsafe(nil), &block); end - # source://parallel//lib/parallel.rb#306 + # source://parallel//lib/parallel.rb#307 + def filter_map(*args, &block); end + + # source://parallel//lib/parallel.rb#303 def flat_map(*args, &block); end - # source://parallel//lib/parallel.rb#231 + # source://parallel//lib/parallel.rb#228 def in_processes(options = T.unsafe(nil), &block); end - # source://parallel//lib/parallel.rb#215 + # source://parallel//lib/parallel.rb#212 def in_threads(options = T.unsafe(nil)); end - # source://parallel//lib/parallel.rb#255 + # source://parallel//lib/parallel.rb#252 def map(source, options = T.unsafe(nil), &block); end - # source://parallel//lib/parallel.rb#302 + # source://parallel//lib/parallel.rb#299 def map_with_index(array, options = T.unsafe(nil), &block); end - # source://parallel//lib/parallel.rb#310 + # Number of physical processor cores on the current system. + # + # source://parallel//lib/parallel.rb#312 + def physical_processor_count; end + + # Number of processors seen by the OS, used for process scheduling + # + # source://parallel//lib/parallel.rb#345 + def processor_count; end + + # source://parallel//lib/parallel.rb#350 def worker_number; end # TODO: this does not work when doing threads in forks, so should remove and yield the number instead if needed # - # source://parallel//lib/parallel.rb#315 + # source://parallel//lib/parallel.rb#355 def worker_number=(worker_num); end private - # source://parallel//lib/parallel.rb#321 + # source://parallel//lib/parallel.rb#361 def add_progress_bar!(job_factory, options); end - # source://parallel//lib/parallel.rb#584 + # source://parallel//lib/parallel.rb#624 def call_with_index(item, index, options, &block); end - # source://parallel//lib/parallel.rb#516 + # source://parallel//lib/parallel.rb#556 def create_workers(job_factory, options, &block); end # options is either a Integer or a Hash with :count # - # source://parallel//lib/parallel.rb#574 + # source://parallel//lib/parallel.rb#614 def extract_count_from_options(options); end - # source://parallel//lib/parallel.rb#602 + # source://parallel//lib/parallel.rb#642 def instrument_finish(item, index, result, options); end - # source://parallel//lib/parallel.rb#607 + # source://parallel//lib/parallel.rb#647 def instrument_start(item, index, options); end - # source://parallel//lib/parallel.rb#550 + # source://parallel//lib/parallel.rb#590 def process_incoming_jobs(read, write, job_factory, options, &block); end - # source://parallel//lib/parallel.rb#504 + # source://parallel//lib/parallel.rb#544 def replace_worker(job_factory, workers, index, options, blk); end - # source://parallel//lib/parallel.rb#595 + # source://parallel//lib/parallel.rb#635 def with_instrumentation(item, index, options); end - # source://parallel//lib/parallel.rb#346 + # source://parallel//lib/parallel.rb#386 def work_direct(job_factory, options, &block); end - # source://parallel//lib/parallel.rb#456 + # source://parallel//lib/parallel.rb#496 def work_in_processes(job_factory, options, &blk); end - # source://parallel//lib/parallel.rb#390 + # source://parallel//lib/parallel.rb#430 def work_in_ractors(job_factory, options); end - # source://parallel//lib/parallel.rb#365 + # source://parallel//lib/parallel.rb#405 def work_in_threads(job_factory, options, &block); end - # source://parallel//lib/parallel.rb#524 + # source://parallel//lib/parallel.rb#564 def worker(job_factory, options, &block); end end end -# source://parallel//lib/parallel.rb#14 +# source://parallel//lib/parallel.rb#11 class Parallel::Break < ::StandardError # @return [Break] a new instance of Break # - # source://parallel//lib/parallel.rb#17 + # source://parallel//lib/parallel.rb#14 def initialize(value = T.unsafe(nil)); end # Returns the value of attribute value. # - # source://parallel//lib/parallel.rb#15 + # source://parallel//lib/parallel.rb#12 def value; end end -# source://parallel//lib/parallel.rb#11 +# source://parallel//lib/parallel.rb#8 class Parallel::DeadWorker < ::StandardError; end -# source://parallel//lib/parallel.rb#35 +# source://parallel//lib/parallel.rb#32 class Parallel::ExceptionWrapper # @return [ExceptionWrapper] a new instance of ExceptionWrapper # - # source://parallel//lib/parallel.rb#38 + # source://parallel//lib/parallel.rb#35 def initialize(exception); end # Returns the value of attribute exception. # - # source://parallel//lib/parallel.rb#36 + # source://parallel//lib/parallel.rb#33 def exception; end end -# source://parallel//lib/parallel.rb#101 +# source://parallel//lib/parallel.rb#98 class Parallel::JobFactory # @return [JobFactory] a new instance of JobFactory # - # source://parallel//lib/parallel.rb#102 + # source://parallel//lib/parallel.rb#99 def initialize(source, mutex); end - # source://parallel//lib/parallel.rb#110 + # source://parallel//lib/parallel.rb#107 def next; end # generate item that is sent to workers # just index is faster + less likely to blow up with unserializable errors # - # source://parallel//lib/parallel.rb#139 + # source://parallel//lib/parallel.rb#136 def pack(item, index); end - # source://parallel//lib/parallel.rb#129 + # source://parallel//lib/parallel.rb#126 def size; end # unpack item that is sent to workers # - # source://parallel//lib/parallel.rb#144 + # source://parallel//lib/parallel.rb#141 def unpack(data); end private # @return [Boolean] # - # source://parallel//lib/parallel.rb#150 + # source://parallel//lib/parallel.rb#147 def producer?; end - # source://parallel//lib/parallel.rb#154 + # source://parallel//lib/parallel.rb#151 def queue_wrapper(array); end end -# source://parallel//lib/parallel.rb#23 +# source://parallel//lib/parallel.rb#20 class Parallel::Kill < ::Parallel::Break; end -# TODO: inline this method into parallel.rb and kill physical_processor_count in next major release -# -# source://parallel//lib/parallel/processor_count.rb#4 -module Parallel::ProcessorCount - # Number of physical processor cores on the current system. - # - # source://parallel//lib/parallel/processor_count.rb#12 - def physical_processor_count; end - - # Number of processors seen by the OS, used for process scheduling - # - # source://parallel//lib/parallel/processor_count.rb#6 - def processor_count; end -end - -# source://parallel//lib/parallel.rb#9 +# source://parallel//lib/parallel.rb#6 Parallel::Stop = T.let(T.unsafe(nil), Object) -# source://parallel//lib/parallel.rb#26 +# source://parallel//lib/parallel.rb#23 class Parallel::UndumpableException < ::StandardError # @return [UndumpableException] a new instance of UndumpableException # - # source://parallel//lib/parallel.rb#29 + # source://parallel//lib/parallel.rb#26 def initialize(original); end # Returns the value of attribute backtrace. # - # source://parallel//lib/parallel.rb#27 + # source://parallel//lib/parallel.rb#24 def backtrace; end end -# source://parallel//lib/parallel.rb#159 +# source://parallel//lib/parallel.rb#156 class Parallel::UserInterruptHandler class << self - # source://parallel//lib/parallel.rb#184 + # source://parallel//lib/parallel.rb#181 def kill(thing); end # kill all these pids or threads if user presses Ctrl+c # - # source://parallel//lib/parallel.rb#164 + # source://parallel//lib/parallel.rb#161 def kill_on_ctrl_c(pids, options); end private - # source://parallel//lib/parallel.rb#208 + # source://parallel//lib/parallel.rb#205 def restore_interrupt(old, signal); end - # source://parallel//lib/parallel.rb#193 + # source://parallel//lib/parallel.rb#190 def trap_interrupt(signal); end end end -# source://parallel//lib/parallel.rb#160 +# source://parallel//lib/parallel.rb#157 Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol) # source://parallel//lib/parallel/version.rb#3 @@ -224,54 +220,54 @@ Parallel::VERSION = T.let(T.unsafe(nil), String) # source://parallel//lib/parallel/version.rb#3 Parallel::Version = T.let(T.unsafe(nil), String) -# source://parallel//lib/parallel.rb#54 +# source://parallel//lib/parallel.rb#51 class Parallel::Worker # @return [Worker] a new instance of Worker # - # source://parallel//lib/parallel.rb#58 + # source://parallel//lib/parallel.rb#55 def initialize(read, write, pid); end # might be passed to started_processes and simultaneously closed by another thread # when running in isolation mode, so we have to check if it is closed before closing # - # source://parallel//lib/parallel.rb#71 + # source://parallel//lib/parallel.rb#68 def close_pipes; end # Returns the value of attribute pid. # - # source://parallel//lib/parallel.rb#55 + # source://parallel//lib/parallel.rb#52 def pid; end # Returns the value of attribute read. # - # source://parallel//lib/parallel.rb#55 + # source://parallel//lib/parallel.rb#52 def read; end - # source://parallel//lib/parallel.rb#64 + # source://parallel//lib/parallel.rb#61 def stop; end # Returns the value of attribute thread. # - # source://parallel//lib/parallel.rb#56 + # source://parallel//lib/parallel.rb#53 def thread; end # Sets the attribute thread # # @param value the value to set the attribute thread to. # - # source://parallel//lib/parallel.rb#56 + # source://parallel//lib/parallel.rb#53 def thread=(_arg0); end - # source://parallel//lib/parallel.rb#76 + # source://parallel//lib/parallel.rb#73 def work(data); end # Returns the value of attribute write. # - # source://parallel//lib/parallel.rb#55 + # source://parallel//lib/parallel.rb#52 def write; end private - # source://parallel//lib/parallel.rb#94 + # source://parallel//lib/parallel.rb#91 def wait; end end diff --git a/sorbet/rbi/gems/parser@3.2.1.1.rbi b/sorbet/rbi/gems/parser@3.2.2.3.rbi similarity index 70% rename from sorbet/rbi/gems/parser@3.2.1.1.rbi rename to sorbet/rbi/gems/parser@3.2.2.3.rbi index c8b57d3f..79fb0cf0 100644 --- a/sorbet/rbi/gems/parser@3.2.1.1.rbi +++ b/sorbet/rbi/gems/parser@3.2.2.3.rbi @@ -7,14 +7,7 @@ # @api public # # source://parser//lib/parser.rb#19 -module Parser - class << self - private - - # source://parser//lib/parser/current.rb#5 - def warn_syntax_deviation(feature, version); end - end -end +module Parser; end # @api public # @@ -663,7 +656,7 @@ end # # @api public # -# source://parser//lib/parser/base.rb#29 +# source://parser//lib/parser/base.rb#16 class Parser::Base < ::Racc::Parser # @api public # @param builder [Parser::Builders::Default] The AST builder to use. @@ -876,7 +869,7 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#243 def initialize; end - # source://parser//lib/parser/builders/default.rb#701 + # source://parser//lib/parser/builders/default.rb#690 def __ENCODING__(__ENCODING__t); end # source://parser//lib/parser/builders/default.rb#348 @@ -885,79 +878,79 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#312 def __LINE__(__LINE__t); end - # source://parser//lib/parser/builders/default.rb#627 + # source://parser//lib/parser/builders/default.rb#616 def accessible(node); end - # source://parser//lib/parser/builders/default.rb#876 + # source://parser//lib/parser/builders/default.rb#865 def alias(alias_t, to, from); end - # source://parser//lib/parser/builders/default.rb#915 + # source://parser//lib/parser/builders/default.rb#904 def arg(name_t); end - # source://parser//lib/parser/builders/default.rb#1005 + # source://parser//lib/parser/builders/default.rb#994 def arg_expr(expr); end - # source://parser//lib/parser/builders/default.rb#885 + # source://parser//lib/parser/builders/default.rb#874 def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end # source://parser//lib/parser/builders/default.rb#440 def array(begin_t, elements, end_t); end - # source://parser//lib/parser/builders/default.rb#1588 + # source://parser//lib/parser/builders/default.rb#1577 def array_pattern(lbrack_t, elements, rbrack_t); end - # source://parser//lib/parser/builders/default.rb#765 + # source://parser//lib/parser/builders/default.rb#754 def assign(lhs, eql_t, rhs); end - # source://parser//lib/parser/builders/default.rb#710 + # source://parser//lib/parser/builders/default.rb#699 def assignable(node); end # source://parser//lib/parser/builders/default.rb#540 def associate(begin_t, pairs, end_t); end - # source://parser//lib/parser/builders/default.rb#1169 + # source://parser//lib/parser/builders/default.rb#1158 def attr_asgn(receiver, dot_t, selector_t); end - # source://parser//lib/parser/builders/default.rb#617 + # source://parser//lib/parser/builders/default.rb#606 def back_ref(token); end - # source://parser//lib/parser/builders/default.rb#1433 + # source://parser//lib/parser/builders/default.rb#1422 def begin(begin_t, body, end_t); end - # source://parser//lib/parser/builders/default.rb#1375 + # source://parser//lib/parser/builders/default.rb#1364 def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1451 + # source://parser//lib/parser/builders/default.rb#1440 def begin_keyword(begin_t, body, end_t); end - # source://parser//lib/parser/builders/default.rb#1203 + # source://parser//lib/parser/builders/default.rb#1192 def binary_op(receiver, operator_t, arg); end - # source://parser//lib/parser/builders/default.rb#1120 + # source://parser//lib/parser/builders/default.rb#1109 def block(method_call, begin_t, args, body, end_t); end - # source://parser//lib/parser/builders/default.rb#1155 + # source://parser//lib/parser/builders/default.rb#1144 def block_pass(amper_t, arg); end - # source://parser//lib/parser/builders/default.rb#980 + # source://parser//lib/parser/builders/default.rb#969 def blockarg(amper_t, name_t); end - # source://parser//lib/parser/builders/default.rb#1025 + # source://parser//lib/parser/builders/default.rb#1014 def blockarg_expr(amper_t, expr); end - # source://parser//lib/parser/builders/default.rb#1111 + # source://parser//lib/parser/builders/default.rb#1100 def call_lambda(lambda_t); end - # source://parser//lib/parser/builders/default.rb#1094 + # source://parser//lib/parser/builders/default.rb#1083 def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1066 + # source://parser//lib/parser/builders/default.rb#1055 def call_type_for_dot(dot_t); end - # source://parser//lib/parser/builders/default.rb#1308 + # source://parser//lib/parser/builders/default.rb#1297 def case(case_t, expr, when_bodies, else_t, else_body, end_t); end - # source://parser//lib/parser/builders/default.rb#1471 + # source://parser//lib/parser/builders/default.rb#1460 def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end # source://parser//lib/parser/builders/default.rb#343 @@ -966,55 +959,55 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#284 def complex(complex_t); end - # source://parser//lib/parser/builders/default.rb#1421 + # source://parser//lib/parser/builders/default.rb#1410 def compstmt(statements); end - # source://parser//lib/parser/builders/default.rb#1284 + # source://parser//lib/parser/builders/default.rb#1273 def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end - # source://parser//lib/parser/builders/default.rb#1290 + # source://parser//lib/parser/builders/default.rb#1279 def condition_mod(if_true, if_false, cond_t, cond); end - # source://parser//lib/parser/builders/default.rb#684 + # source://parser//lib/parser/builders/default.rb#673 def const(name_t); end - # source://parser//lib/parser/builders/default.rb#696 + # source://parser//lib/parser/builders/default.rb#685 def const_fetch(scope, t_colon2, name_t); end - # source://parser//lib/parser/builders/default.rb#689 + # source://parser//lib/parser/builders/default.rb#678 def const_global(t_colon3, name_t); end - # source://parser//lib/parser/builders/default.rb#761 + # source://parser//lib/parser/builders/default.rb#750 def const_op_assignable(node); end - # source://parser//lib/parser/builders/default.rb#1618 + # source://parser//lib/parser/builders/default.rb#1607 def const_pattern(const, ldelim_t, pattern, rdelim_t); end - # source://parser//lib/parser/builders/default.rb#612 + # source://parser//lib/parser/builders/default.rb#601 def cvar(token); end # source://parser//lib/parser/builders/default.rb#388 def dedent_string(node, dedent_level); end - # source://parser//lib/parser/builders/default.rb#812 + # source://parser//lib/parser/builders/default.rb#801 def def_class(class_t, name, lt_t, superclass, body, end_t); end - # source://parser//lib/parser/builders/default.rb#843 + # source://parser//lib/parser/builders/default.rb#832 def def_endless_method(def_t, name_t, args, assignment_t, body); end - # source://parser//lib/parser/builders/default.rb#861 + # source://parser//lib/parser/builders/default.rb#850 def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end - # source://parser//lib/parser/builders/default.rb#835 + # source://parser//lib/parser/builders/default.rb#824 def def_method(def_t, name_t, args, body, end_t); end - # source://parser//lib/parser/builders/default.rb#825 + # source://parser//lib/parser/builders/default.rb#814 def def_module(module_t, name, body, end_t); end - # source://parser//lib/parser/builders/default.rb#819 + # source://parser//lib/parser/builders/default.rb#808 def def_sclass(class_t, lshft_t, expr, body, end_t); end - # source://parser//lib/parser/builders/default.rb#851 + # source://parser//lib/parser/builders/default.rb#840 def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end # source://parser//lib/parser/builders/default.rb#237 @@ -1026,157 +1019,157 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#265 def false(false_t); end - # source://parser//lib/parser/builders/default.rb#1609 + # source://parser//lib/parser/builders/default.rb#1598 def find_pattern(lbrack_t, elements, rbrack_t); end # source://parser//lib/parser/builders/default.rb#276 def float(float_t); end - # source://parser//lib/parser/builders/default.rb#1329 + # source://parser//lib/parser/builders/default.rb#1318 def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end - # source://parser//lib/parser/builders/default.rb#911 + # source://parser//lib/parser/builders/default.rb#900 def forward_arg(dots_t); end - # source://parser//lib/parser/builders/default.rb#901 + # source://parser//lib/parser/builders/default.rb#890 def forward_only_args(begin_t, dots_t, end_t); end - # source://parser//lib/parser/builders/default.rb#1082 + # source://parser//lib/parser/builders/default.rb#1071 def forwarded_args(dots_t); end - # source://parser//lib/parser/builders/default.rb#1090 + # source://parser//lib/parser/builders/default.rb#1079 def forwarded_kwrestarg(dstar_t); end - # source://parser//lib/parser/builders/default.rb#1086 + # source://parser//lib/parser/builders/default.rb#1075 def forwarded_restarg(star_t); end - # source://parser//lib/parser/builders/default.rb#607 + # source://parser//lib/parser/builders/default.rb#596 def gvar(token); end - # source://parser//lib/parser/builders/default.rb#1582 + # source://parser//lib/parser/builders/default.rb#1571 def hash_pattern(lbrace_t, kwargs, rbrace_t); end - # source://parser//lib/parser/builders/default.rb#597 + # source://parser//lib/parser/builders/default.rb#586 def ident(token); end - # source://parser//lib/parser/builders/default.rb#1498 + # source://parser//lib/parser/builders/default.rb#1487 def if_guard(if_t, if_body); end - # source://parser//lib/parser/builders/default.rb#1477 + # source://parser//lib/parser/builders/default.rb#1466 def in_match(lhs, in_t, rhs); end - # source://parser//lib/parser/builders/default.rb#1492 + # source://parser//lib/parser/builders/default.rb#1481 def in_pattern(in_t, pattern, guard, then_t, body); end - # source://parser//lib/parser/builders/default.rb#1178 + # source://parser//lib/parser/builders/default.rb#1167 def index(receiver, lbrack_t, indexes, rbrack_t); end - # source://parser//lib/parser/builders/default.rb#1192 + # source://parser//lib/parser/builders/default.rb#1181 def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end # source://parser//lib/parser/builders/default.rb#272 def integer(integer_t); end - # source://parser//lib/parser/builders/default.rb#602 + # source://parser//lib/parser/builders/default.rb#591 def ivar(token); end - # source://parser//lib/parser/builders/default.rb#1337 + # source://parser//lib/parser/builders/default.rb#1326 def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#942 + # source://parser//lib/parser/builders/default.rb#931 def kwarg(name_t); end - # source://parser//lib/parser/builders/default.rb#968 + # source://parser//lib/parser/builders/default.rb#957 def kwnilarg(dstar_t, nil_t); end - # source://parser//lib/parser/builders/default.rb#949 + # source://parser//lib/parser/builders/default.rb#938 def kwoptarg(name_t, value); end - # source://parser//lib/parser/builders/default.rb#956 + # source://parser//lib/parser/builders/default.rb#945 def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end # source://parser//lib/parser/builders/default.rb#535 def kwsplat(dstar_t, arg); end - # source://parser//lib/parser/builders/default.rb#1277 + # source://parser//lib/parser/builders/default.rb#1266 def logical_op(type, lhs, op_t, rhs); end - # source://parser//lib/parser/builders/default.rb#1315 + # source://parser//lib/parser/builders/default.rb#1304 def loop(type, keyword_t, cond, do_t, body, end_t); end - # source://parser//lib/parser/builders/default.rb#1320 + # source://parser//lib/parser/builders/default.rb#1309 def loop_mod(type, body, keyword_t, cond); end - # source://parser//lib/parser/builders/default.rb#1632 + # source://parser//lib/parser/builders/default.rb#1621 def match_alt(left, pipe_t, right); end - # source://parser//lib/parser/builders/default.rb#1639 + # source://parser//lib/parser/builders/default.rb#1628 def match_as(value, assoc_t, as); end - # source://parser//lib/parser/builders/default.rb#1518 + # source://parser//lib/parser/builders/default.rb#1507 def match_hash_var(name_t); end - # source://parser//lib/parser/builders/default.rb#1532 + # source://parser//lib/parser/builders/default.rb#1521 def match_hash_var_from_str(begin_t, strings, end_t); end - # source://parser//lib/parser/builders/default.rb#1670 + # source://parser//lib/parser/builders/default.rb#1659 def match_label(label_type, label); end - # source://parser//lib/parser/builders/default.rb#1646 + # source://parser//lib/parser/builders/default.rb#1635 def match_nil_pattern(dstar_t, nil_t); end - # source://parser//lib/parser/builders/default.rb#1225 + # source://parser//lib/parser/builders/default.rb#1214 def match_op(receiver, match_t, arg); end - # source://parser//lib/parser/builders/default.rb#1651 + # source://parser//lib/parser/builders/default.rb#1640 def match_pair(label_type, label, value); end - # source://parser//lib/parser/builders/default.rb#1482 + # source://parser//lib/parser/builders/default.rb#1471 def match_pattern(lhs, match_t, rhs); end - # source://parser//lib/parser/builders/default.rb#1487 + # source://parser//lib/parser/builders/default.rb#1476 def match_pattern_p(lhs, match_t, rhs); end - # source://parser//lib/parser/builders/default.rb#1571 + # source://parser//lib/parser/builders/default.rb#1560 def match_rest(star_t, name_t = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1506 + # source://parser//lib/parser/builders/default.rb#1495 def match_var(name_t); end - # source://parser//lib/parser/builders/default.rb#1614 + # source://parser//lib/parser/builders/default.rb#1603 def match_with_trailing_comma(match, comma_t); end - # source://parser//lib/parser/builders/default.rb#803 + # source://parser//lib/parser/builders/default.rb#792 def multi_assign(lhs, eql_t, rhs); end - # source://parser//lib/parser/builders/default.rb#798 + # source://parser//lib/parser/builders/default.rb#787 def multi_lhs(begin_t, items, end_t); end # source://parser//lib/parser/builders/default.rb#255 def nil(nil_t); end - # source://parser//lib/parser/builders/default.rb#1253 + # source://parser//lib/parser/builders/default.rb#1242 def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#622 + # source://parser//lib/parser/builders/default.rb#611 def nth_ref(token); end - # source://parser//lib/parser/builders/default.rb#897 + # source://parser//lib/parser/builders/default.rb#886 def numargs(max_numparam); end - # source://parser//lib/parser/builders/default.rb#1036 + # source://parser//lib/parser/builders/default.rb#1025 def objc_kwarg(kwname_t, assoc_t, name_t); end - # source://parser//lib/parser/builders/default.rb#1050 + # source://parser//lib/parser/builders/default.rb#1039 def objc_restarg(star_t, name = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1160 + # source://parser//lib/parser/builders/default.rb#1149 def objc_varargs(pair, rest_of_varargs); end - # source://parser//lib/parser/builders/default.rb#772 + # source://parser//lib/parser/builders/default.rb#761 def op_assign(lhs, op_t, rhs); end - # source://parser//lib/parser/builders/default.rb#922 + # source://parser//lib/parser/builders/default.rb#911 def optarg(name_t, eql_t, value); end # source://parser//lib/parser/builders/default.rb#488 @@ -1200,22 +1193,22 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#225 def parser=(_arg0); end - # source://parser//lib/parser/builders/default.rb#1627 + # source://parser//lib/parser/builders/default.rb#1616 def pin(pin_t, var); end - # source://parser//lib/parser/builders/default.rb#1360 + # source://parser//lib/parser/builders/default.rb#1349 def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end - # source://parser//lib/parser/builders/default.rb#1355 + # source://parser//lib/parser/builders/default.rb#1344 def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end - # source://parser//lib/parser/builders/default.rb#990 + # source://parser//lib/parser/builders/default.rb#979 def procarg0(arg); end - # source://parser//lib/parser/builders/default.rb#583 + # source://parser//lib/parser/builders/default.rb#572 def range_exclusive(lhs, dot3_t, rhs); end - # source://parser//lib/parser/builders/default.rb#578 + # source://parser//lib/parser/builders/default.rb#567 def range_inclusive(lhs, dot2_t, rhs); end # source://parser//lib/parser/builders/default.rb#280 @@ -1227,19 +1220,19 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#417 def regexp_options(regopt_t); end - # source://parser//lib/parser/builders/default.rb#1367 + # source://parser//lib/parser/builders/default.rb#1356 def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end - # source://parser//lib/parser/builders/default.rb#931 + # source://parser//lib/parser/builders/default.rb#920 def restarg(star_t, name_t = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1014 + # source://parser//lib/parser/builders/default.rb#1003 def restarg_expr(star_t, expr = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#592 + # source://parser//lib/parser/builders/default.rb#581 def self(token); end - # source://parser//lib/parser/builders/default.rb#973 + # source://parser//lib/parser/builders/default.rb#962 def shadowarg(name_t); end # source://parser//lib/parser/builders/default.rb#445 @@ -1266,7 +1259,7 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#469 def symbols_compose(begin_t, parts, end_t); end - # source://parser//lib/parser/builders/default.rb#1295 + # source://parser//lib/parser/builders/default.rb#1284 def ternary(cond, question_t, if_true, colon_t, if_false); end # source://parser//lib/parser/builders/default.rb#260 @@ -1275,16 +1268,16 @@ class Parser::Builders::Default # source://parser//lib/parser/builders/default.rb#294 def unary_num(unary_t, numeric); end - # source://parser//lib/parser/builders/default.rb#1241 + # source://parser//lib/parser/builders/default.rb#1230 def unary_op(op_t, receiver); end - # source://parser//lib/parser/builders/default.rb#871 + # source://parser//lib/parser/builders/default.rb#860 def undef_method(undef_t, names); end - # source://parser//lib/parser/builders/default.rb#1502 + # source://parser//lib/parser/builders/default.rb#1491 def unless_guard(unless_t, unless_body); end - # source://parser//lib/parser/builders/default.rb#1302 + # source://parser//lib/parser/builders/default.rb#1291 def when(when_t, patterns, then_t, body); end # source://parser//lib/parser/builders/default.rb#455 @@ -1298,184 +1291,184 @@ class Parser::Builders::Default private - # source://parser//lib/parser/builders/default.rb#1809 + # source://parser//lib/parser/builders/default.rb#1798 def arg_name_collides?(this_name, that_name); end - # source://parser//lib/parser/builders/default.rb#2005 + # source://parser//lib/parser/builders/default.rb#1994 def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1979 + # source://parser//lib/parser/builders/default.rb#1968 def binary_op_map(left_e, op_t, right_e); end - # source://parser//lib/parser/builders/default.rb#2107 + # source://parser//lib/parser/builders/default.rb#2096 def block_map(receiver_l, begin_t, end_t); end - # source://parser//lib/parser/builders/default.rb#1784 + # source://parser//lib/parser/builders/default.rb#1773 def check_assignment_to_numparam(name, loc); end - # source://parser//lib/parser/builders/default.rb#1686 + # source://parser//lib/parser/builders/default.rb#1675 def check_condition(cond); end - # source://parser//lib/parser/builders/default.rb#1755 + # source://parser//lib/parser/builders/default.rb#1744 def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1730 + # source://parser//lib/parser/builders/default.rb#1719 def check_duplicate_args(args, map = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1842 + # source://parser//lib/parser/builders/default.rb#1831 def check_duplicate_pattern_key(name, loc); end - # source://parser//lib/parser/builders/default.rb#1832 + # source://parser//lib/parser/builders/default.rb#1821 def check_duplicate_pattern_variable(name, loc); end - # source://parser//lib/parser/builders/default.rb#1824 + # source://parser//lib/parser/builders/default.rb#1813 def check_lvar_name(name, loc); end - # source://parser//lib/parser/builders/default.rb#1799 + # source://parser//lib/parser/builders/default.rb#1788 def check_reserved_for_numparam(name, loc); end - # source://parser//lib/parser/builders/default.rb#2264 + # source://parser//lib/parser/builders/default.rb#2253 def collapse_string_parts?(parts); end - # source://parser//lib/parser/builders/default.rb#1930 + # source://parser//lib/parser/builders/default.rb#1919 def collection_map(begin_t, parts, end_t); end - # source://parser//lib/parser/builders/default.rb#2134 + # source://parser//lib/parser/builders/default.rb#2123 def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end - # source://parser//lib/parser/builders/default.rb#1965 + # source://parser//lib/parser/builders/default.rb#1954 def constant_map(scope, colon2_t, name_t); end - # source://parser//lib/parser/builders/default.rb#2038 + # source://parser//lib/parser/builders/default.rb#2027 def definition_map(keyword_t, operator_t, name_t, end_t); end - # source://parser//lib/parser/builders/default.rb#1871 + # source://parser//lib/parser/builders/default.rb#1860 def delimited_string_map(string_t); end - # source://parser//lib/parser/builders/default.rb#2286 + # source://parser//lib/parser/builders/default.rb#2275 def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#2178 + # source://parser//lib/parser/builders/default.rb#2167 def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end - # source://parser//lib/parser/builders/default.rb#2044 + # source://parser//lib/parser/builders/default.rb#2033 def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end - # source://parser//lib/parser/builders/default.rb#1926 + # source://parser//lib/parser/builders/default.rb#1915 def expr_map(loc); end - # source://parser//lib/parser/builders/default.rb#2159 + # source://parser//lib/parser/builders/default.rb#2148 def for_map(keyword_t, in_t, begin_t, end_t); end - # source://parser//lib/parser/builders/default.rb#2206 + # source://parser//lib/parser/builders/default.rb#2195 def guard_map(keyword_t, guard_body_e); end - # source://parser//lib/parser/builders/default.rb#2096 + # source://parser//lib/parser/builders/default.rb#2085 def index_map(receiver_e, lbrack_t, rbrack_t); end - # source://parser//lib/parser/builders/default.rb#1862 + # source://parser//lib/parser/builders/default.rb#1851 def join_exprs(left_expr, right_expr); end - # source://parser//lib/parser/builders/default.rb#2112 + # source://parser//lib/parser/builders/default.rb#2101 def keyword_map(keyword_t, begin_t, args, end_t); end - # source://parser//lib/parser/builders/default.rb#2129 + # source://parser//lib/parser/builders/default.rb#2118 def keyword_mod_map(pre_e, keyword_t, post_e); end - # source://parser//lib/parser/builders/default.rb#2015 + # source://parser//lib/parser/builders/default.rb#2004 def kwarg_map(name_t, value_e = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#2317 + # source://parser//lib/parser/builders/default.rb#2306 def kwargs?(node); end - # source://parser//lib/parser/builders/default.rb#2281 + # source://parser//lib/parser/builders/default.rb#2270 def loc(token); end - # source://parser//lib/parser/builders/default.rb#2028 + # source://parser//lib/parser/builders/default.rb#2017 def module_definition_map(keyword_t, name_e, operator_t, end_t); end - # source://parser//lib/parser/builders/default.rb#1854 + # source://parser//lib/parser/builders/default.rb#1843 def n(type, children, source_map); end - # source://parser//lib/parser/builders/default.rb#1858 + # source://parser//lib/parser/builders/default.rb#1847 def n0(type, source_map); end # source://parser//lib/parser/builders/default.rb#288 def numeric(kind, token); end - # source://parser//lib/parser/builders/default.rb#1896 + # source://parser//lib/parser/builders/default.rb#1885 def pair_keyword_map(key_t, value_e); end - # source://parser//lib/parser/builders/default.rb#1911 + # source://parser//lib/parser/builders/default.rb#1900 def pair_quoted_map(begin_t, end_t, value_e); end - # source://parser//lib/parser/builders/default.rb#1882 + # source://parser//lib/parser/builders/default.rb#1871 def prefix_string_map(symbol); end - # source://parser//lib/parser/builders/default.rb#1993 + # source://parser//lib/parser/builders/default.rb#1982 def range_map(start_e, op_t, end_e); end - # source://parser//lib/parser/builders/default.rb#1960 + # source://parser//lib/parser/builders/default.rb#1949 def regexp_map(begin_t, end_t, options_e); end - # source://parser//lib/parser/builders/default.rb#2165 + # source://parser//lib/parser/builders/default.rb#2154 def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end - # source://parser//lib/parser/builders/default.rb#2307 + # source://parser//lib/parser/builders/default.rb#2296 def rewrite_hash_args_to_kwargs(args); end - # source://parser//lib/parser/builders/default.rb#2078 + # source://parser//lib/parser/builders/default.rb#2067 def send_binary_op_map(lhs_e, selector_t, rhs_e); end - # source://parser//lib/parser/builders/default.rb#2101 + # source://parser//lib/parser/builders/default.rb#2090 def send_index_map(receiver_e, lbrack_t, rbrack_t); end - # source://parser//lib/parser/builders/default.rb#2052 + # source://parser//lib/parser/builders/default.rb#2041 def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#2084 + # source://parser//lib/parser/builders/default.rb#2073 def send_unary_op_map(selector_t, arg_e); end - # source://parser//lib/parser/builders/default.rb#2237 + # source://parser//lib/parser/builders/default.rb#2226 def static_regexp(parts, options); end - # source://parser//lib/parser/builders/default.rb#2257 + # source://parser//lib/parser/builders/default.rb#2246 def static_regexp_node(node); end - # source://parser//lib/parser/builders/default.rb#2220 + # source://parser//lib/parser/builders/default.rb#2209 def static_string(nodes); end - # source://parser//lib/parser/builders/default.rb#1946 + # source://parser//lib/parser/builders/default.rb#1935 def string_map(begin_t, parts, end_t); end - # source://parser//lib/parser/builders/default.rb#2273 + # source://parser//lib/parser/builders/default.rb#2262 def string_value(token); end - # source://parser//lib/parser/builders/default.rb#2154 + # source://parser//lib/parser/builders/default.rb#2143 def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end - # source://parser//lib/parser/builders/default.rb#1867 + # source://parser//lib/parser/builders/default.rb#1856 def token_map(token); end - # source://parser//lib/parser/builders/default.rb#1983 + # source://parser//lib/parser/builders/default.rb#1972 def unary_op_map(op_t, arg_e = T.unsafe(nil)); end - # source://parser//lib/parser/builders/default.rb#1891 + # source://parser//lib/parser/builders/default.rb#1880 def unquoted_map(token); end - # source://parser//lib/parser/builders/default.rb#2295 + # source://parser//lib/parser/builders/default.rb#2284 def validate_definee(definee); end - # source://parser//lib/parser/builders/default.rb#1769 + # source://parser//lib/parser/builders/default.rb#1758 def validate_no_forward_arg_after_restarg(args); end - # source://parser//lib/parser/builders/default.rb#2269 + # source://parser//lib/parser/builders/default.rb#2258 def value(token); end - # source://parser//lib/parser/builders/default.rb#2072 + # source://parser//lib/parser/builders/default.rb#2061 def var_send_map(variable_e); end - # source://parser//lib/parser/builders/default.rb#1975 + # source://parser//lib/parser/builders/default.rb#1964 def variable_map(name_t); end class << self @@ -1671,9 +1664,6 @@ class Parser::CurrentArgStack def top; end end -# source://parser//lib/parser/current.rb#102 -Parser::CurrentRuby = Parser::Ruby31 - # @api private # # source://parser//lib/parser/deprecation.rb#7 @@ -3234,7 +3224,7 @@ Parser::Meta::NODE_TYPES = T.let(T.unsafe(nil), Set) # @api public # @deprecated Use {Parser::TreeRewriter} # -# source://parser//lib/parser/rewriter.rb#22 +# source://parser//lib/parser/rewriter.rb#14 class Parser::Rewriter < ::Parser::AST::Processor extend ::Parser::Deprecation @@ -3315,1797 +3305,6 @@ end # source://parser//lib/parser/rewriter.rb#91 Parser::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) -# source://parser//lib/parser/ruby31.rb#14 -class Parser::Ruby31 < ::Parser::Base - # reduce 0 omitted - # - # source://parser//lib/parser/ruby31.rb#8433 - def _reduce_1(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8487 - def _reduce_10(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9122 - def _reduce_100(val, _values, result); end - - # reduce 101 omitted - # - # source://parser//lib/parser/ruby31.rb#9131 - def _reduce_102(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9137 - def _reduce_103(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9143 - def _reduce_104(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9149 - def _reduce_105(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9155 - def _reduce_106(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9161 - def _reduce_107(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9167 - def _reduce_108(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9173 - def _reduce_109(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8493 - def _reduce_11(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9179 - def _reduce_110(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9189 - def _reduce_111(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9195 - def _reduce_112(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9205 - def _reduce_113(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9212 - def _reduce_114(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9219 - def _reduce_115(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9225 - def _reduce_116(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9231 - def _reduce_117(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9237 - def _reduce_118(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9243 - def _reduce_119(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8510 - def _reduce_12(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9249 - def _reduce_120(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9255 - def _reduce_121(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9261 - def _reduce_122(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9268 - def _reduce_123(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9275 - def _reduce_124(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9281 - def _reduce_125(val, _values, result); end - - # reduce 126 omitted - # - # source://parser//lib/parser/ruby31.rb#9289 - def _reduce_127(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9295 - def _reduce_128(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9301 - def _reduce_129(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8516 - def _reduce_13(val, _values, result); end - - # reduce 134 omitted - # - # source://parser//lib/parser/ruby31.rb#9317 - def _reduce_135(val, _values, result); end - - # reduce 136 omitted - # - # source://parser//lib/parser/ruby31.rb#9325 - def _reduce_137(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9331 - def _reduce_138(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9337 - def _reduce_139(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8522 - def _reduce_14(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8528 - def _reduce_15(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8534 - def _reduce_16(val, _values, result); end - - # reduce 17 omitted - # - # source://parser//lib/parser/ruby31.rb#8542 - def _reduce_18(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8548 - def _reduce_19(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8440 - def _reduce_2(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8554 - def _reduce_20(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8560 - def _reduce_21(val, _values, result); end - - # reduce 210 omitted - # - # source://parser//lib/parser/ruby31.rb#9485 - def _reduce_211(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9491 - def _reduce_212(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9497 - def _reduce_213(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9506 - def _reduce_214(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9515 - def _reduce_215(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9524 - def _reduce_216(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9533 - def _reduce_217(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9541 - def _reduce_218(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9549 - def _reduce_219(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8568 - def _reduce_22(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9555 - def _reduce_220(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9561 - def _reduce_221(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9567 - def _reduce_222(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9573 - def _reduce_223(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9579 - def _reduce_224(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9585 - def _reduce_225(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9591 - def _reduce_226(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9597 - def _reduce_227(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9603 - def _reduce_228(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9609 - def _reduce_229(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8576 - def _reduce_23(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9615 - def _reduce_230(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9621 - def _reduce_231(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9627 - def _reduce_232(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9635 - def _reduce_233(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9641 - def _reduce_234(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9647 - def _reduce_235(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9653 - def _reduce_236(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9659 - def _reduce_237(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9665 - def _reduce_238(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8582 - def _reduce_24(val, _values, result); end - - # reduce 239 omitted - # - # source://parser//lib/parser/ruby31.rb#9673 - def _reduce_240(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9679 - def _reduce_241(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9685 - def _reduce_242(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9691 - def _reduce_243(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9697 - def _reduce_244(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9703 - def _reduce_245(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9709 - def _reduce_246(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9715 - def _reduce_247(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9721 - def _reduce_248(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9727 - def _reduce_249(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8588 - def _reduce_25(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9733 - def _reduce_250(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9739 - def _reduce_251(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9745 - def _reduce_252(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9752 - def _reduce_253(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9759 - def _reduce_254(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9773 - def _reduce_255(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9793 - def _reduce_256(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9807 - def _reduce_257(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8595 - def _reduce_26(val, _values, result); end - - # reduce 262 omitted - # - # source://parser//lib/parser/ruby31.rb#9837 - def _reduce_263(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9843 - def _reduce_264(val, _values, result); end - - # reduce 267 omitted - # - # source://parser//lib/parser/ruby31.rb#9855 - def _reduce_268(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9861 - def _reduce_269(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8602 - def _reduce_27(val, _values, result); end - - # reduce 270 omitted - # - # source://parser//lib/parser/ruby31.rb#9869 - def _reduce_271(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9879 - def _reduce_272(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9885 - def _reduce_273(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9895 - def _reduce_274(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9905 - def _reduce_275(val, _values, result); end - - # reduce 276 omitted - # - # source://parser//lib/parser/ruby31.rb#9913 - def _reduce_277(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8608 - def _reduce_28(val, _values, result); end - - # reduce 279 omitted - # - # source://parser//lib/parser/ruby31.rb#9923 - def _reduce_280(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9929 - def _reduce_281(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9935 - def _reduce_282(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9941 - def _reduce_283(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9947 - def _reduce_284(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9954 - def _reduce_285(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9962 - def _reduce_286(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9968 - def _reduce_287(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9995 - def _reduce_288(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10016 - def _reduce_289(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8614 - def _reduce_29(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10022 - def _reduce_290(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10032 - def _reduce_291(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10038 - def _reduce_292(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10044 - def _reduce_293(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10050 - def _reduce_294(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10056 - def _reduce_295(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10062 - def _reduce_296(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10068 - def _reduce_297(val, _values, result); end - - # reduce 298 omitted - # - # source://parser//lib/parser/ruby31.rb#10076 - def _reduce_299(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8449 - def _reduce_3(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8624 - def _reduce_30(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10082 - def _reduce_300(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10088 - def _reduce_301(val, _values, result); end - - # reduce 311 omitted - # - # source://parser//lib/parser/ruby31.rb#10114 - def _reduce_312(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10120 - def _reduce_313(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10126 - def _reduce_314(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10134 - def _reduce_315(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10140 - def _reduce_316(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10146 - def _reduce_317(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10152 - def _reduce_318(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10158 - def _reduce_319(val, _values, result); end - - # reduce 31 omitted - # - # source://parser//lib/parser/ruby31.rb#8632 - def _reduce_32(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10164 - def _reduce_320(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10170 - def _reduce_321(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10176 - def _reduce_322(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10182 - def _reduce_323(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10188 - def _reduce_324(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10194 - def _reduce_325(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10200 - def _reduce_326(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10206 - def _reduce_327(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10212 - def _reduce_328(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10218 - def _reduce_329(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8638 - def _reduce_33(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10226 - def _reduce_330(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10232 - def _reduce_331(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10238 - def _reduce_332(val, _values, result); end - - # reduce 333 omitted - # - # source://parser//lib/parser/ruby31.rb#10250 - def _reduce_334(val, _values, result); end - - # reduce 335 omitted - # - # source://parser//lib/parser/ruby31.rb#10260 - def _reduce_336(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10269 - def _reduce_337(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10278 - def _reduce_338(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10284 - def _reduce_339(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8645 - def _reduce_34(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10290 - def _reduce_340(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10300 - def _reduce_341(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10310 - def _reduce_342(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10320 - def _reduce_343(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10326 - def _reduce_344(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10333 - def _reduce_345(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10349 - def _reduce_346(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10357 - def _reduce_347(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10369 - def _reduce_348(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10376 - def _reduce_349(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8656 - def _reduce_35(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10390 - def _reduce_350(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10402 - def _reduce_351(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10414 - def _reduce_352(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10420 - def _reduce_353(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10426 - def _reduce_354(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10432 - def _reduce_355(val, _values, result); end - - # reduce 356 omitted - # - # source://parser//lib/parser/ruby31.rb#10440 - def _reduce_357(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10446 - def _reduce_358(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10452 - def _reduce_359(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10459 - def _reduce_360(val, _values, result); end - - # reduce 362 omitted - # - # source://parser//lib/parser/ruby31.rb#10471 - def _reduce_363(val, _values, result); end - - # reduce 366 omitted - # - # source://parser//lib/parser/ruby31.rb#10483 - def _reduce_367(val, _values, result); end - - # reduce 368 omitted - # - # source://parser//lib/parser/ruby31.rb#10496 - def _reduce_369(val, _values, result); end - - # reduce 36 omitted - # - # source://parser//lib/parser/ruby31.rb#8664 - def _reduce_37(val, _values, result); end - - # reduce 371 omitted - # - # source://parser//lib/parser/ruby31.rb#10506 - def _reduce_372(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10512 - def _reduce_373(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10518 - def _reduce_374(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10524 - def _reduce_375(val, _values, result); end - - # reduce 376 omitted - # - # source://parser//lib/parser/ruby31.rb#10532 - def _reduce_377(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10539 - def _reduce_378(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10547 - def _reduce_379(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8670 - def _reduce_38(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10553 - def _reduce_380(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10559 - def _reduce_381(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10565 - def _reduce_382(val, _values, result); end - - # reduce 384 omitted - # - # source://parser//lib/parser/ruby31.rb#10575 - def _reduce_385(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10581 - def _reduce_386(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10587 - def _reduce_387(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10593 - def _reduce_388(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10599 - def _reduce_389(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8676 - def _reduce_39(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10605 - def _reduce_390(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10611 - def _reduce_391(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10617 - def _reduce_392(val, _values, result); end - - # reduce 393 omitted - # - # source://parser//lib/parser/ruby31.rb#10625 - def _reduce_394(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10634 - def _reduce_395(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10644 - def _reduce_396(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10652 - def _reduce_397(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10661 - def _reduce_398(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8455 - def _reduce_4(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8685 - def _reduce_40(val, _values, result); end - - # reduce 399 omitted - # - # source://parser//lib/parser/ruby31.rb#10671 - def _reduce_400(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10680 - def _reduce_401(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10690 - def _reduce_402(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10698 - def _reduce_403(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10707 - def _reduce_404(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10714 - def _reduce_405(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10722 - def _reduce_406(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10729 - def _reduce_407(val, _values, result); end - - # reduce 408 omitted - # - # source://parser//lib/parser/ruby31.rb#10739 - def _reduce_409(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8694 - def _reduce_41(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10745 - def _reduce_410(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10751 - def _reduce_411(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10760 - def _reduce_412(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10769 - def _reduce_413(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10775 - def _reduce_414(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10781 - def _reduce_415(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10787 - def _reduce_416(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10793 - def _reduce_417(val, _values, result); end - - # reduce 418 omitted - # - # source://parser//lib/parser/ruby31.rb#10802 - def _reduce_419(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8703 - def _reduce_42(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10811 - def _reduce_420(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10817 - def _reduce_421(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10833 - def _reduce_422(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10841 - def _reduce_423(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10851 - def _reduce_424(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10858 - def _reduce_425(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10865 - def _reduce_426(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10872 - def _reduce_427(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10879 - def _reduce_428(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10886 - def _reduce_429(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8711 - def _reduce_43(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10893 - def _reduce_430(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10901 - def _reduce_431(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10909 - def _reduce_432(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10921 - def _reduce_433(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10932 - def _reduce_434(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10940 - def _reduce_435(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10948 - def _reduce_436(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10956 - def _reduce_437(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10962 - def _reduce_438(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10970 - def _reduce_439(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8720 - def _reduce_44(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10978 - def _reduce_440(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10986 - def _reduce_441(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10992 - def _reduce_442(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#10998 - def _reduce_443(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11005 - def _reduce_444(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11012 - def _reduce_445(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11019 - def _reduce_446(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11026 - def _reduce_447(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11033 - def _reduce_448(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11043 - def _reduce_449(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8734 - def _reduce_45(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11050 - def _reduce_450(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11056 - def _reduce_451(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11067 - def _reduce_452(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11074 - def _reduce_453(val, _values, result); end - - # reduce 454 omitted - # - # source://parser//lib/parser/ruby31.rb#11082 - def _reduce_455(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11094 - def _reduce_456(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11102 - def _reduce_457(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11109 - def _reduce_458(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8754 - def _reduce_46(val, _values, result); end - - # reduce 459 omitted - # - # source://parser//lib/parser/ruby31.rb#11117 - def _reduce_460(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11123 - def _reduce_461(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11129 - def _reduce_462(val, _values, result); end - - # reduce 463 omitted - # - # source://parser//lib/parser/ruby31.rb#11137 - def _reduce_464(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11147 - def _reduce_465(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11153 - def _reduce_466(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11159 - def _reduce_467(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11165 - def _reduce_468(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8768 - def _reduce_47(val, _values, result); end - - # reduce 469 omitted - # - # source://parser//lib/parser/ruby31.rb#11173 - def _reduce_470(val, _values, result); end - - # reduce 471 omitted - # - # source://parser//lib/parser/ruby31.rb#11181 - def _reduce_472(val, _values, result); end - - # reduce 473 omitted - # - # source://parser//lib/parser/ruby31.rb#11189 - def _reduce_474(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11196 - def _reduce_475(val, _values, result); end - - # reduce 477 omitted - # - # source://parser//lib/parser/ruby31.rb#11207 - def _reduce_478(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11215 - def _reduce_479(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8788 - def _reduce_48(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11223 - def _reduce_480(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11231 - def _reduce_481(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11238 - def _reduce_482(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11246 - def _reduce_483(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11254 - def _reduce_484(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11262 - def _reduce_485(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11269 - def _reduce_486(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11275 - def _reduce_487(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11281 - def _reduce_488(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11287 - def _reduce_489(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11295 - def _reduce_490(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11303 - def _reduce_491(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11309 - def _reduce_492(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11315 - def _reduce_493(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11322 - def _reduce_494(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11328 - def _reduce_495(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11334 - def _reduce_496(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11340 - def _reduce_497(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11347 - def _reduce_498(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11354 - def _reduce_499(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8461 - def _reduce_5(val, _values, result); end - - # reduce 49 omitted - # - # source://parser//lib/parser/ruby31.rb#8796 - def _reduce_50(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11360 - def _reduce_500(val, _values, result); end - - # reduce 501 omitted - # - # source://parser//lib/parser/ruby31.rb#11368 - def _reduce_502(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11378 - def _reduce_503(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11388 - def _reduce_504(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11394 - def _reduce_505(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11400 - def _reduce_506(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11406 - def _reduce_507(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11412 - def _reduce_508(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11418 - def _reduce_509(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11424 - def _reduce_510(val, _values, result); end - - # reduce 511 omitted - # - # source://parser//lib/parser/ruby31.rb#11432 - def _reduce_512(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11438 - def _reduce_513(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11444 - def _reduce_514(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11450 - def _reduce_515(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11456 - def _reduce_516(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11462 - def _reduce_517(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11468 - def _reduce_518(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11474 - def _reduce_519(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11480 - def _reduce_520(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11486 - def _reduce_521(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11492 - def _reduce_522(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11498 - def _reduce_523(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11504 - def _reduce_524(val, _values, result); end - - # reduce 527 omitted - # - # source://parser//lib/parser/ruby31.rb#11516 - def _reduce_528(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11522 - def _reduce_529(val, _values, result); end - - # reduce 52 omitted - # - # source://parser//lib/parser/ruby31.rb#8810 - def _reduce_53(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11528 - def _reduce_530(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11534 - def _reduce_531(val, _values, result); end - - # reduce 534 omitted - # - # source://parser//lib/parser/ruby31.rb#11546 - def _reduce_535(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11552 - def _reduce_536(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8816 - def _reduce_54(val, _values, result); end - - # reduce 544 omitted - # - # source://parser//lib/parser/ruby31.rb#11574 - def _reduce_545(val, _values, result); end - - # reduce 546 omitted - # - # source://parser//lib/parser/ruby31.rb#11582 - def _reduce_547(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11588 - def _reduce_548(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11600 - def _reduce_549(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8822 - def _reduce_55(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11607 - def _reduce_550(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11614 - def _reduce_551(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11620 - def _reduce_552(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11626 - def _reduce_553(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11632 - def _reduce_554(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11647 - def _reduce_555(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11653 - def _reduce_556(val, _values, result); end - - # reduce 558 omitted - # - # source://parser//lib/parser/ruby31.rb#11663 - def _reduce_559(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8828 - def _reduce_56(val, _values, result); end - - # reduce 560 omitted - # - # source://parser//lib/parser/ruby31.rb#11671 - def _reduce_561(val, _values, result); end - - # reduce 564 omitted - # - # source://parser//lib/parser/ruby31.rb#11683 - def _reduce_565(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11689 - def _reduce_566(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11695 - def _reduce_567(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11701 - def _reduce_568(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11708 - def _reduce_569(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8834 - def _reduce_57(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11715 - def _reduce_570(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11721 - def _reduce_571(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11728 - def _reduce_572(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11735 - def _reduce_573(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11741 - def _reduce_574(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11747 - def _reduce_575(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11753 - def _reduce_576(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11759 - def _reduce_577(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11765 - def _reduce_578(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11771 - def _reduce_579(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8846 - def _reduce_58(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11777 - def _reduce_580(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11783 - def _reduce_581(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11789 - def _reduce_582(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11795 - def _reduce_583(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11801 - def _reduce_584(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11807 - def _reduce_585(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11813 - def _reduce_586(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11819 - def _reduce_587(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11825 - def _reduce_588(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11831 - def _reduce_589(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8855 - def _reduce_59(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11837 - def _reduce_590(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11843 - def _reduce_591(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11849 - def _reduce_592(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11855 - def _reduce_593(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11861 - def _reduce_594(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11867 - def _reduce_595(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11874 - def _reduce_596(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11883 - def _reduce_597(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11889 - def _reduce_598(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11895 - def _reduce_599(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8467 - def _reduce_6(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8867 - def _reduce_60(val, _values, result); end - - # reduce 602 omitted - # - # source://parser//lib/parser/ruby31.rb#11907 - def _reduce_603(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11914 - def _reduce_604(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11921 - def _reduce_605(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11927 - def _reduce_606(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11938 - def _reduce_607(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11945 - def _reduce_608(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11952 - def _reduce_609(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11959 - def _reduce_610(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11966 - def _reduce_611(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11972 - def _reduce_612(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11978 - def _reduce_613(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11984 - def _reduce_614(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11990 - def _reduce_615(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#11996 - def _reduce_616(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12002 - def _reduce_617(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12008 - def _reduce_618(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12014 - def _reduce_619(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12020 - def _reduce_620(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12026 - def _reduce_621(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12032 - def _reduce_622(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12038 - def _reduce_623(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12044 - def _reduce_624(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12050 - def _reduce_625(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12056 - def _reduce_626(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12062 - def _reduce_627(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12068 - def _reduce_628(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12074 - def _reduce_629(val, _values, result); end - - # reduce 62 omitted - # - # source://parser//lib/parser/ruby31.rb#8880 - def _reduce_63(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12080 - def _reduce_630(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12086 - def _reduce_631(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12092 - def _reduce_632(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12098 - def _reduce_633(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12104 - def _reduce_634(val, _values, result); end - - # reduce 635 omitted - # - # source://parser//lib/parser/ruby31.rb#12112 - def _reduce_636(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12119 - def _reduce_637(val, _values, result); end - - # reduce 638 omitted - # - # source://parser//lib/parser/ruby31.rb#12130 - def _reduce_639(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8886 - def _reduce_64(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12138 - def _reduce_640(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12146 - def _reduce_641(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12152 - def _reduce_642(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12158 - def _reduce_643(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12164 - def _reduce_644(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12170 - def _reduce_645(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12177 - def _reduce_646(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12183 - def _reduce_647(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12189 - def _reduce_648(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12198 - def _reduce_649(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8893 - def _reduce_65(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12208 - def _reduce_650(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12216 - def _reduce_651(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12225 - def _reduce_652(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12233 - def _reduce_653(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12242 - def _reduce_654(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12249 - def _reduce_655(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12257 - def _reduce_656(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12266 - def _reduce_657(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12273 - def _reduce_658(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12281 - def _reduce_659(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8903 - def _reduce_66(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12288 - def _reduce_660(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12296 - def _reduce_661(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12302 - def _reduce_662(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12308 - def _reduce_663(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12314 - def _reduce_664(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12320 - def _reduce_665(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12326 - def _reduce_666(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12332 - def _reduce_667(val, _values, result); end - - # reduce 668 omitted - # - # source://parser//lib/parser/ruby31.rb#12340 - def _reduce_669(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8909 - def _reduce_67(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12350 - def _reduce_670(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12357 - def _reduce_671(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12364 - def _reduce_672(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12370 - def _reduce_673(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12376 - def _reduce_674(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12382 - def _reduce_675(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12397 - def _reduce_676(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12405 - def _reduce_677(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12413 - def _reduce_678(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12420 - def _reduce_679(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8916 - def _reduce_68(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12427 - def _reduce_680(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12433 - def _reduce_681(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12439 - def _reduce_682(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12445 - def _reduce_683(val, _values, result); end - - # reduce 685 omitted - # - # source://parser//lib/parser/ruby31.rb#12455 - def _reduce_686(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12461 - def _reduce_687(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12469 - def _reduce_688(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12475 - def _reduce_689(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12483 - def _reduce_690(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12491 - def _reduce_691(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12497 - def _reduce_692(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12503 - def _reduce_693(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12509 - def _reduce_694(val, _values, result); end - - # reduce 696 omitted - # - # source://parser//lib/parser/ruby31.rb#12519 - def _reduce_697(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12527 - def _reduce_698(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8473 - def _reduce_7(val, _values, result); end - - # reduce 700 omitted - # - # source://parser//lib/parser/ruby31.rb#12537 - def _reduce_701(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12545 - def _reduce_702(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12553 - def _reduce_703(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12559 - def _reduce_704(val, _values, result); end - - # reduce 705 omitted - # - # source://parser//lib/parser/ruby31.rb#12567 - def _reduce_706(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12573 - def _reduce_707(val, _values, result); end - - # reduce 708 omitted - # - # source://parser//lib/parser/ruby31.rb#12581 - def _reduce_709(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12587 - def _reduce_710(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12593 - def _reduce_711(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12599 - def _reduce_712(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12605 - def _reduce_713(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12611 - def _reduce_714(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12617 - def _reduce_715(val, _values, result); end - - # reduce 71 omitted - # - # source://parser//lib/parser/ruby31.rb#8928 - def _reduce_72(val, _values, result); end - - # reduce 727 omitted - # - # source://parser//lib/parser/ruby31.rb#12647 - def _reduce_728(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12653 - def _reduce_729(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8935 - def _reduce_73(val, _values, result); end - - # reduce 733 omitted - # - # source://parser//lib/parser/ruby31.rb#12667 - def _reduce_734(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12673 - def _reduce_735(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12679 - def _reduce_736(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8942 - def _reduce_74(val, _values, result); end - - # reduce 739 omitted - # - # source://parser//lib/parser/ruby31.rb#12691 - def _reduce_740(val, _values, result); end - - # reduce 743 omitted - # - # source://parser//lib/parser/ruby31.rb#12703 - def _reduce_744(val, _values, result); end - - # reduce 75 omitted - # - # source://parser//lib/parser/ruby31.rb#8951 - def _reduce_76(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8958 - def _reduce_77(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8969 - def _reduce_78(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8976 - def _reduce_79(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8987 - def _reduce_80(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#8994 - def _reduce_81(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9005 - def _reduce_82(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9012 - def _reduce_83(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9019 - def _reduce_84(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9026 - def _reduce_85(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9033 - def _reduce_86(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9040 - def _reduce_87(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9046 - def _reduce_88(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9052 - def _reduce_89(val, _values, result); end - - # reduce 8 omitted - # - # source://parser//lib/parser/ruby31.rb#8481 - def _reduce_9(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9058 - def _reduce_90(val, _values, result); end - - # reduce 91 omitted - # - # source://parser//lib/parser/ruby31.rb#9066 - def _reduce_92(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9073 - def _reduce_93(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9080 - def _reduce_94(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9088 - def _reduce_95(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9095 - def _reduce_96(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9103 - def _reduce_97(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9109 - def _reduce_98(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#9116 - def _reduce_99(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#12709 - def _reduce_none(val, _values, result); end - - # source://parser//lib/parser/ruby31.rb#21 - def default_encoding; end - - # source://parser//lib/parser/ruby31.rb#25 - def endless_method_name(name_t); end - - # source://parser//lib/parser/ruby31.rb#38 - def local_pop; end - - # source://parser//lib/parser/ruby31.rb#31 - def local_push; end - - # source://parser//lib/parser/ruby31.rb#45 - def try_declare_numparam(node); end - - # source://parser//lib/parser/ruby31.rb#17 - def version; end -end - -# source://parser//lib/parser/ruby31.rb#8022 -Parser::Ruby31::Racc_arg = T.let(T.unsafe(nil), Array) - -# source://parser//lib/parser/ruby31.rb#8427 -Parser::Ruby31::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass) - -# source://parser//lib/parser/ruby31.rb#8038 -Parser::Ruby31::Racc_token_to_s_table = T.let(T.unsafe(nil), Array) - # @api public # # source://parser//lib/parser.rb#30 @@ -7148,7 +5347,7 @@ end # # @api public # -# source://parser//lib/parser/tree_rewriter.rb#61 +# source://parser//lib/parser/tree_rewriter.rb#51 class Parser::TreeRewriter < ::Parser::AST::Processor # Returns `true` if the specified node is an assignment node, returns false # otherwise. diff --git a/sorbet/rbi/gems/prettier_print@1.2.1.rbi b/sorbet/rbi/gems/prettier_print@1.2.1.rbi new file mode 100644 index 00000000..4e885250 --- /dev/null +++ b/sorbet/rbi/gems/prettier_print@1.2.1.rbi @@ -0,0 +1,951 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `prettier_print` gem. +# Please instead update this file by running `bin/tapioca gem prettier_print`. + +# This class implements a pretty printing algorithm. It finds line breaks and +# nice indentations for grouped structure. +# +# By default, the class assumes that primitive elements are strings and each +# byte in the strings is a single column in width. But it can be used for other +# situations by giving suitable arguments for some methods: +# +# * newline object and space generation block for PrettierPrint.new +# * optional width argument for PrettierPrint#text +# * PrettierPrint#breakable +# +# There are several candidate uses: +# * text formatting using proportional fonts +# * multibyte characters which has columns different to number of bytes +# * non-string formatting +# +# == Usage +# +# To use this module, you will need to generate a tree of print nodes that +# represent indentation and newline behavior before it gets sent to the printer. +# Each node has different semantics, depending on the desired output. +# +# The most basic node is a Text node. This represents plain text content that +# cannot be broken up even if it doesn't fit on one line. You would create one +# of those with the text method, as in: +# +# PrettierPrint.format { |q| q.text('my content') } +# +# No matter what the desired output width is, the output for the snippet above +# will always be the same. +# +# If you want to allow the printer to break up the content on the space +# character when there isn't enough width for the full string on the same line, +# you can use the Breakable and Group nodes. For example: +# +# PrettierPrint.format do |q| +# q.group do +# q.text("my") +# q.breakable +# q.text("content") +# end +# end +# +# Now, if everything fits on one line (depending on the maximum width specified) +# then it will be the same output as the first example. If, however, there is +# not enough room on the line, then you will get two lines of output, one for +# the first string and one for the second. +# +# There are other nodes for the print tree as well, described in the +# documentation below. They control alignment, indentation, conditional +# formatting, and more. +# +# == References +# Christian Lindig, Strictly Pretty, March 2000 +# https://lindig.github.io/papers/strictly-pretty-2000.pdf +# +# Philip Wadler, A prettier printer, March 1998 +# https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf +# +# source://prettier_print//lib/prettier_print.rb#62 +class PrettierPrint + # Creates a buffer for pretty printing. + # + # +output+ is an output target. If it is not specified, '' is assumed. It + # should have a << method which accepts the first argument +obj+ of + # PrettierPrint#text, the first argument +separator+ of PrettierPrint#breakable, + # the first argument +newline+ of PrettierPrint.new, and the result of a given + # block for PrettierPrint.new. + # + # +maxwidth+ specifies maximum line length. If it is not specified, 80 is + # assumed. However actual outputs may overflow +maxwidth+ if long + # non-breakable texts are provided. + # + # +newline+ is used for line breaks. "\n" is used if it is not specified. + # + # The block is used to generate spaces. ->(n) { ' ' * n } is used if it is not + # given. + # + # @return [PrettierPrint] a new instance of PrettierPrint + # + # source://prettier_print//lib/prettier_print.rb#441 + def initialize(output = T.unsafe(nil), maxwidth = T.unsafe(nil), newline = T.unsafe(nil), &genspace); end + + # This inserts a BreakParent node into the print tree which forces the + # surrounding and all parent group nodes to break. + # + # source://prettier_print//lib/prettier_print.rb#814 + def break_parent; end + + # This says "you can break a line here if necessary", and a +width+\-column + # text +separator+ is inserted if a line is not broken at the point. + # + # If +separator+ is not specified, ' ' is used. + # + # If +width+ is not specified, +separator.length+ is used. You will have to + # specify this when +separator+ is a multibyte character, for example. + # + # By default, if the surrounding group is broken and a newline is inserted, + # the printer will indent the subsequent line up to the current level of + # indentation. You can disable this behavior with the +indent+ argument if + # that's not desired (rare). + # + # By default, when you insert a Breakable into the print tree, it only breaks + # the surrounding group when the group's contents cannot fit onto the + # remaining space of the current line. You can force it to break the + # surrounding group instead if you always want the newline with the +force+ + # argument. + # + # There are a few circumstances where you'll want to force the newline into + # the output but no insert a break parent (because you don't want to + # necessarily force the groups to break unless they need to). In this case you + # can pass `force: :skip_break_parent` to this method and it will not insert + # a break parent.` + # + # source://prettier_print//lib/prettier_print.rb#802 + def breakable(separator = T.unsafe(nil), width = T.unsafe(nil), indent: T.unsafe(nil), force: T.unsafe(nil)); end + + # Another very common breakable call you receive while formatting is an + # empty string in flat mode and a newline in break mode. Similar to + # breakable_space, this is here for avoid unnecessary calculation. + # + # source://prettier_print//lib/prettier_print.rb#646 + def breakable_empty; end + + # The final of the very common breakable calls you receive while formatting + # is the normal breakable space but with the addition of the break_parent. + # + # source://prettier_print//lib/prettier_print.rb#652 + def breakable_force; end + + # This is the same shortcut as breakable_force, except that it doesn't indent + # the next line. This is necessary if you're trying to preserve some custom + # formatting like a multi-line string. + # + # source://prettier_print//lib/prettier_print.rb#660 + def breakable_return; end + + # The vast majority of breakable calls you receive while formatting are a + # space in flat mode and a newline in break mode. Since this is so common, + # we have a method here to skip past unnecessary calculation. + # + # source://prettier_print//lib/prettier_print.rb#639 + def breakable_space; end + + # This is an output buffer that wraps the output object and provides + # additional functionality depending on its type. + # + # This defaults to Buffer::StringBuffer.new("".dup) + # + # source://prettier_print//lib/prettier_print.rb#400 + def buffer; end + + # A convenience method which is same as follows: + # + # text(",") + # breakable + # + # source://prettier_print//lib/prettier_print.rb#669 + def comma_breakable; end + + # Returns the group most recently added to the stack. + # + # Contrived example: + # out = "" + # => "" + # q = PrettierPrint.new(out) + # => # + # q.group { + # q.text q.current_group.inspect + # q.text q.newline + # q.group(q.current_group.depth + 1) { + # q.text q.current_group.inspect + # q.text q.newline + # q.group(q.current_group.depth + 1) { + # q.text q.current_group.inspect + # q.text q.newline + # q.group(q.current_group.depth + 1) { + # q.text q.current_group.inspect + # q.text q.newline + # } + # } + # } + # } + # => 284 + # puts out + # # + # # + # # + # # + # + # source://prettier_print//lib/prettier_print.rb#484 + def current_group; end + + # This is similar to #breakable except the decision to break or not is + # determined individually. + # + # Two #fill_breakable under a group may cause 4 results: + # (break,break), (break,non-break), (non-break,break), (non-break,non-break). + # This is different to #breakable because two #breakable under a group + # may cause 2 results: (break,break), (non-break,non-break). + # + # The text +separator+ is inserted if a line is not broken at this point. + # + # If +separator+ is not specified, ' ' is used. + # + # If +width+ is not specified, +separator.length+ is used. You will have to + # specify this when +separator+ is a multibyte character, for example. + # + # source://prettier_print//lib/prettier_print.rb#688 + def fill_breakable(separator = T.unsafe(nil), width = T.unsafe(nil)); end + + # Flushes all of the generated print tree onto the output buffer, then clears + # the generated tree from memory. + # + # source://prettier_print//lib/prettier_print.rb#490 + def flush(base_indentation = T.unsafe(nil)); end + + # An object that responds to call that takes one argument, of an Integer, and + # returns the corresponding number of spaces. + # + # By default this is: ->(n) { ' ' * n } + # + # source://prettier_print//lib/prettier_print.rb#416 + def genspace; end + + # Groups line break hints added in the block. The line break hints are all to + # be used or not. + # + # If +indent+ is specified, the method call is regarded as nested by + # nest(indent) { ... }. + # + # If +open_object+ is specified, text(open_object, open_width) is + # called before grouping. If +close_object+ is specified, + # text(close_object, close_width) is called after grouping. + # + # source://prettier_print//lib/prettier_print.rb#845 + def group(indent = T.unsafe(nil), open_object = T.unsafe(nil), close_object = T.unsafe(nil), open_width = T.unsafe(nil), close_width = T.unsafe(nil)); end + + # The stack of groups that are being printed. + # + # source://prettier_print//lib/prettier_print.rb#419 + def groups; end + + # Inserts an IfBreak node with the contents of the block being added to its + # list of nodes that should be printed if the surrounding node breaks. If it + # doesn't, then you can specify the contents to be printed with the #if_flat + # method used on the return object from this method. For example, + # + # q.if_break { q.text('do') }.if_flat { q.text('{') } + # + # In the example above, if the surrounding group is broken it will print 'do' + # and if it is not it will print '{'. + # + # source://prettier_print//lib/prettier_print.rb#917 + def if_break; end + + # This is similar to if_break in that it also inserts an IfBreak node into the + # print tree, however it's starting from the flat contents, and cannot be used + # to build the break contents. + # + # source://prettier_print//lib/prettier_print.rb#936 + def if_flat; end + + # Very similar to the #nest method, this indents the nested content by one + # level by inserting an Indent node into the print tree. The contents of the + # node are determined by the block. + # + # source://prettier_print//lib/prettier_print.rb#956 + def indent; end + + # This method calculates the position of the text relative to the current + # indentation level when the doc has been printed. It's useful for + # determining how to align text to doc nodes that are already built into the + # tree. + # + # source://prettier_print//lib/prettier_print.rb#696 + def last_position(node); end + + # Inserts a LineSuffix node into the print tree. The contents of the node are + # determined by the block. + # + # source://prettier_print//lib/prettier_print.rb#967 + def line_suffix(priority: T.unsafe(nil)); end + + # The maximum width of a line, before it is separated in to a newline + # + # This defaults to 80, and should be an Integer + # + # source://prettier_print//lib/prettier_print.rb#405 + def maxwidth; end + + # Increases left margin after newline with +indent+ for line breaks added in + # the block. + # + # source://prettier_print//lib/prettier_print.rb#977 + def nest(indent); end + + # The value that is appended to +output+ to add a new line. + # + # This defaults to "\n", and should be String + # + # source://prettier_print//lib/prettier_print.rb#410 + def newline; end + + # The output object. It represents the final destination of the contents of + # the print tree. It should respond to <<. + # + # This defaults to "".dup + # + # source://prettier_print//lib/prettier_print.rb#394 + def output; end + + # This method will remove any breakables from the list of contents so that + # no newlines are present in the output. If a newline is being forced into + # the output, the replace value will be used. + # + # source://prettier_print//lib/prettier_print.rb#721 + def remove_breaks(node, replace = T.unsafe(nil)); end + + # Adds a separated list. + # The list is separated by comma with breakable space, by default. + # + # #seplist iterates the +list+ using +iter_method+. + # It yields each object to the block given for #seplist. + # The procedure +separator_proc+ is called between each yields. + # + # If the iteration is zero times, +separator_proc+ is not called at all. + # + # If +separator_proc+ is nil or not given, + # +lambda { comma_breakable }+ is used. + # If +iter_method+ is not given, :each is used. + # + # For example, following 3 code fragments has similar effect. + # + # q.seplist([1,2,3]) {|v| xxx v } + # + # q.seplist([1,2,3], lambda { q.comma_breakable }, :each) {|v| xxx v } + # + # xxx 1 + # q.comma_breakable + # xxx 2 + # q.comma_breakable + # xxx 3 + # + # source://prettier_print//lib/prettier_print.rb#760 + def seplist(list, sep = T.unsafe(nil), iter_method = T.unsafe(nil)); end + + # The current array of contents that calls to methods that generate print tree + # nodes will append to. + # + # source://prettier_print//lib/prettier_print.rb#423 + def target; end + + # This adds +object+ as a text of +width+ columns in width. + # + # If +width+ is not specified, object.length is used. + # + # source://prettier_print//lib/prettier_print.rb#989 + def text(object = T.unsafe(nil), width = T.unsafe(nil)); end + + # This inserts a Trim node into the print tree which, when printed, will clear + # all whitespace at the end of the output buffer. This is useful for the rare + # case where you need to delete printed indentation and force the next node + # to start at the beginning of the line. + # + # source://prettier_print//lib/prettier_print.rb#828 + def trim; end + + # A convenience method used by a lot of the print tree node builders that + # temporarily changes the target that the builders will append to. + # + # source://prettier_print//lib/prettier_print.rb#1007 + def with_target(target); end + + private + + # This method returns a boolean as to whether or not the remaining commands + # fit onto the remaining space on the current line. If we finish printing + # all of the commands or if we hit a newline, then we return true. Otherwise + # if we continue printing past the remaining space, we return false. + # + # @return [Boolean] + # + # source://prettier_print//lib/prettier_print.rb#1019 + def fits?(next_commands, rest_commands, remaining); end + + # source://prettier_print//lib/prettier_print.rb#1091 + def remove_breaks_with(doc, replace); end + + # Resets the group stack and target array so that this pretty printer object + # can continue to be used before calling flush again if desired. + # + # source://prettier_print//lib/prettier_print.rb#1085 + def reset; end + + class << self + # This is a convenience method which is same as follows: + # + # begin + # q = PrettierPrint.new(output, maxwidth, newline, &genspace) + # ... + # q.flush + # output + # end + # + # @yield [q] + # + # source://prettier_print//lib/prettier_print.rb#377 + def format(output = T.unsafe(nil), maxwidth = T.unsafe(nil), newline = T.unsafe(nil), genspace = T.unsafe(nil), indentation = T.unsafe(nil)); end + + # This is similar to PrettierPrint::format but the result has no breaks. + # + # +maxwidth+, +newline+ and +genspace+ are ignored. + # + # The invocation of +breakable+ in the block doesn't break a line and is + # treated as just an invocation of +text+. + # + # @yield [q] + # + # source://prettier_print//lib/prettier_print/single_line.rb#156 + def singleline_format(output = T.unsafe(nil), _maxwidth = T.unsafe(nil), _newline = T.unsafe(nil), _genspace = T.unsafe(nil)); end + end +end + +# A node in the print tree that represents aligning nested nodes to a certain +# prefix width or string. +# +# source://prettier_print//lib/prettier_print.rb#65 +class PrettierPrint::Align + # @return [Align] a new instance of Align + # + # source://prettier_print//lib/prettier_print.rb#68 + def initialize(indent:, contents: T.unsafe(nil)); end + + # Returns the value of attribute contents. + # + # source://prettier_print//lib/prettier_print.rb#66 + def contents; end + + # Returns the value of attribute indent. + # + # source://prettier_print//lib/prettier_print.rb#66 + def indent; end + + # source://prettier_print//lib/prettier_print.rb#73 + def pretty_print(q); end +end + +# source://prettier_print//lib/prettier_print.rb#126 +PrettierPrint::BREAKABLE_EMPTY = T.let(T.unsafe(nil), PrettierPrint::Breakable) + +# source://prettier_print//lib/prettier_print.rb#127 +PrettierPrint::BREAKABLE_FORCE = T.let(T.unsafe(nil), PrettierPrint::Breakable) + +# source://prettier_print//lib/prettier_print.rb#128 +PrettierPrint::BREAKABLE_RETURN = T.let(T.unsafe(nil), PrettierPrint::Breakable) + +# Below here are the most common combination of options that are created when +# creating new breakables. They are here to cut down on some allocations. +# +# source://prettier_print//lib/prettier_print.rb#125 +PrettierPrint::BREAKABLE_SPACE = T.let(T.unsafe(nil), PrettierPrint::Breakable) + +# Since there's really no difference in these instances, just using the same +# one saves on some allocations. +# +# source://prettier_print//lib/prettier_print.rb#141 +PrettierPrint::BREAK_PARENT = T.let(T.unsafe(nil), PrettierPrint::BreakParent) + +# A node in the print tree that forces the surrounding group to print out in +# the "break" mode as opposed to the "flat" mode. Useful for when you need to +# force a newline into a group. +# +# source://prettier_print//lib/prettier_print.rb#133 +class PrettierPrint::BreakParent + # source://prettier_print//lib/prettier_print.rb#134 + def pretty_print(q); end +end + +# A node in the print tree that represents a place in the buffer that the +# content can be broken onto multiple lines. +# +# source://prettier_print//lib/prettier_print.rb#82 +class PrettierPrint::Breakable + # @return [Breakable] a new instance of Breakable + # + # source://prettier_print//lib/prettier_print.rb#85 + def initialize(separator = T.unsafe(nil), width = T.unsafe(nil), force: T.unsafe(nil), indent: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://prettier_print//lib/prettier_print.rb#97 + def force?; end + + # @return [Boolean] + # + # source://prettier_print//lib/prettier_print.rb#101 + def indent?; end + + # source://prettier_print//lib/prettier_print.rb#105 + def pretty_print(q); end + + # Returns the value of attribute separator. + # + # source://prettier_print//lib/prettier_print.rb#83 + def separator; end + + # Returns the value of attribute width. + # + # source://prettier_print//lib/prettier_print.rb#83 + def width; end +end + +# When building up the contents in the output buffer, it's convenient to be +# able to trim trailing whitespace before newlines. If the output object is a +# string or array or strings, then we can do this with some gsub calls. If +# not, then this effectively just wraps the output object and forwards on +# calls to <<. +# +# source://prettier_print//lib/prettier_print.rb#277 +module PrettierPrint::Buffer + class << self + # This is a switch for building the correct output buffer wrapper class for + # the given output object. + # + # source://prettier_print//lib/prettier_print.rb#336 + def for(output); end + end +end + +# This is an output buffer that wraps an array output object. It provides a +# trim! method that trims off trailing whitespace from the last element in +# the array if it's an unfrozen string using the same method as the +# StringBuffer. +# +# source://prettier_print//lib/prettier_print.rb#303 +class PrettierPrint::Buffer::ArrayBuffer + # @return [ArrayBuffer] a new instance of ArrayBuffer + # + # source://prettier_print//lib/prettier_print.rb#306 + def initialize(output = T.unsafe(nil)); end + + # source://prettier_print//lib/prettier_print.rb#310 + def <<(object); end + + # Returns the value of attribute output. + # + # source://prettier_print//lib/prettier_print.rb#304 + def output; end + + # source://prettier_print//lib/prettier_print.rb#314 + def trim!; end +end + +# This is an output buffer that wraps a string output object. It provides a +# trim! method that trims off trailing whitespace from the string using +# gsub!. +# +# source://prettier_print//lib/prettier_print.rb#281 +class PrettierPrint::Buffer::StringBuffer + # @return [StringBuffer] a new instance of StringBuffer + # + # source://prettier_print//lib/prettier_print.rb#284 + def initialize(output = T.unsafe(nil)); end + + # source://prettier_print//lib/prettier_print.rb#288 + def <<(object); end + + # Returns the value of attribute output. + # + # source://prettier_print//lib/prettier_print.rb#282 + def output; end + + # source://prettier_print//lib/prettier_print.rb#292 + def trim!; end +end + +# When generating spaces after a newline for indentation, by default we +# generate one space per character needed for indentation. You can change this +# behavior (for instance to use tabs) by passing a different genspace +# procedure. +# +# source://prettier_print//lib/prettier_print.rb#350 +PrettierPrint::DEFAULT_GENSPACE = T.let(T.unsafe(nil), Proc) + +# The default indentation for printing is zero, assuming that the code starts +# at the top level. That can be changed if desired to start from a different +# indentation level. +# +# source://prettier_print//lib/prettier_print.rb#366 +PrettierPrint::DEFAULT_INDENTATION = T.let(T.unsafe(nil), Integer) + +# When printing, you can optionally specify the value that should be used +# whenever a group needs to be broken onto multiple lines. In this case the +# default is \n. +# +# source://prettier_print//lib/prettier_print.rb#344 +PrettierPrint::DEFAULT_NEWLINE = T.let(T.unsafe(nil), String) + +# A node in the print tree that represents a group of items which the printer +# should try to fit onto one line. This is the basic command to tell the +# printer when to break. Groups are usually nested, and the printer will try +# to fit everything on one line, but if it doesn't fit it will break the +# outermost group first and try again. It will continue breaking groups until +# everything fits (or there are no more groups to break). +# +# source://prettier_print//lib/prettier_print.rb#149 +class PrettierPrint::Group + # @return [Group] a new instance of Group + # + # source://prettier_print//lib/prettier_print.rb#152 + def initialize(depth, contents: T.unsafe(nil)); end + + # source://prettier_print//lib/prettier_print.rb#158 + def break; end + + # @return [Boolean] + # + # source://prettier_print//lib/prettier_print.rb#162 + def break?; end + + # Returns the value of attribute contents. + # + # source://prettier_print//lib/prettier_print.rb#150 + def contents; end + + # Returns the value of attribute depth. + # + # source://prettier_print//lib/prettier_print.rb#150 + def depth; end + + # source://prettier_print//lib/prettier_print.rb#166 + def pretty_print(q); end +end + +# A node in the print tree that represents printing one thing if the +# surrounding group node is broken and another thing if the surrounding group +# node is flat. +# +# source://prettier_print//lib/prettier_print.rb#176 +class PrettierPrint::IfBreak + # @return [IfBreak] a new instance of IfBreak + # + # source://prettier_print//lib/prettier_print.rb#179 + def initialize(break_contents: T.unsafe(nil), flat_contents: T.unsafe(nil)); end + + # Returns the value of attribute break_contents. + # + # source://prettier_print//lib/prettier_print.rb#177 + def break_contents; end + + # Returns the value of attribute flat_contents. + # + # source://prettier_print//lib/prettier_print.rb#177 + def flat_contents; end + + # source://prettier_print//lib/prettier_print.rb#184 + def pretty_print(q); end +end + +# A small DSL-like object used for specifying the alternative contents to be +# printed if the surrounding group doesn't break for an IfBreak node. +# +# source://prettier_print//lib/prettier_print.rb#874 +class PrettierPrint::IfBreakBuilder + # @return [IfBreakBuilder] a new instance of IfBreakBuilder + # + # source://prettier_print//lib/prettier_print.rb#877 + def initialize(q, flat_contents); end + + # Returns the value of attribute flat_contents. + # + # source://prettier_print//lib/prettier_print.rb#875 + def flat_contents; end + + # source://prettier_print//lib/prettier_print.rb#882 + def if_flat; end + + # Returns the value of attribute q. + # + # source://prettier_print//lib/prettier_print.rb#875 + def q; end +end + +# When we already know that groups are broken, we don't actually need to track +# the flat versions of the contents. So this builder version is effectively a +# no-op, but we need it to maintain the same API. The only thing this can +# impact is that if there's a forced break in the flat contents, then we need +# to propagate that break up the whole tree. +# +# source://prettier_print//lib/prettier_print.rb#892 +class PrettierPrint::IfFlatIgnore + # @return [IfFlatIgnore] a new instance of IfFlatIgnore + # + # source://prettier_print//lib/prettier_print.rb#895 + def initialize(q); end + + # source://prettier_print//lib/prettier_print.rb#899 + def if_flat; end + + # Returns the value of attribute q. + # + # source://prettier_print//lib/prettier_print.rb#893 + def q; end +end + +# A node in the print tree that is a variant of the Align node that indents +# its contents by one level. +# +# source://prettier_print//lib/prettier_print.rb#200 +class PrettierPrint::Indent + # @return [Indent] a new instance of Indent + # + # source://prettier_print//lib/prettier_print.rb#203 + def initialize(contents: T.unsafe(nil)); end + + # Returns the value of attribute contents. + # + # source://prettier_print//lib/prettier_print.rb#201 + def contents; end + + # source://prettier_print//lib/prettier_print.rb#207 + def pretty_print(q); end +end + +# A node in the print tree that has its own special buffer for implementing +# content that should flush before any newline. +# +# Useful for implementating trailing content, as it's not always practical to +# constantly check where the line ends to avoid accidentally printing some +# content after a line suffix node. +# +# source://prettier_print//lib/prettier_print.rb#220 +class PrettierPrint::LineSuffix + # @return [LineSuffix] a new instance of LineSuffix + # + # source://prettier_print//lib/prettier_print.rb#225 + def initialize(priority: T.unsafe(nil), contents: T.unsafe(nil)); end + + # Returns the value of attribute contents. + # + # source://prettier_print//lib/prettier_print.rb#223 + def contents; end + + # source://prettier_print//lib/prettier_print.rb#230 + def pretty_print(q); end + + # Returns the value of attribute priority. + # + # source://prettier_print//lib/prettier_print.rb#223 + def priority; end +end + +# source://prettier_print//lib/prettier_print.rb#221 +PrettierPrint::LineSuffix::DEFAULT_PRIORITY = T.let(T.unsafe(nil), Integer) + +# There are two modes in printing, break and flat. When we're in break mode, +# any lines will use their newline, any if-breaks will use their break +# contents, etc. +# +# source://prettier_print//lib/prettier_print.rb#356 +PrettierPrint::MODE_BREAK = T.let(T.unsafe(nil), Integer) + +# This is another print mode much like MODE_BREAK. When we're in flat mode, we +# attempt to print everything on one line until we either hit a broken group, +# a forced line, or the maximum width. +# +# source://prettier_print//lib/prettier_print.rb#361 +PrettierPrint::MODE_FLAT = T.let(T.unsafe(nil), Integer) + +# PrettierPrint::SingleLine is used by PrettierPrint.singleline_format +# +# It is passed to be similar to a PrettierPrint object itself, by responding to +# all of the same print tree node builder methods, as well as the #flush +# method. +# +# The significant difference here is that there are no line breaks in the +# output. If an IfBreak node is used, only the flat contents are printed. +# LineSuffix nodes are printed at the end of the buffer when #flush is called. +# +# source://prettier_print//lib/prettier_print/single_line.rb#13 +class PrettierPrint::SingleLine + # Create a PrettierPrint::SingleLine object + # + # Arguments: + # * +output+ - String (or similar) to store rendered text. Needs to respond + # to '<<'. + # * +maxwidth+ - Argument position expected to be here for compatibility. + # This argument is a noop. + # * +newline+ - Argument position expected to be here for compatibility. + # This argument is a noop. + # + # @return [SingleLine] a new instance of SingleLine + # + # source://prettier_print//lib/prettier_print/single_line.rb#34 + def initialize(output, _maxwidth = T.unsafe(nil), _newline = T.unsafe(nil)); end + + # Here for compatibility, does nothing. + # + # source://prettier_print//lib/prettier_print/single_line.rb#64 + def break_parent; end + + # Appends +separator+ to the text to be output. By default +separator+ is + # ' ' + # + # The +width+, +indent+, and +force+ arguments are here for compatibility. + # They are all noop arguments. + # + # source://prettier_print//lib/prettier_print/single_line.rb#54 + def breakable(separator = T.unsafe(nil), _width = T.unsafe(nil), indent: T.unsafe(nil), force: T.unsafe(nil)); end + + # Appends +separator+ to the output buffer. +width+ is a noop here for + # compatibility. + # + # source://prettier_print//lib/prettier_print/single_line.rb#69 + def fill_breakable(separator = T.unsafe(nil), _width = T.unsafe(nil)); end + + # Flushes the line suffixes onto the output buffer. + # + # source://prettier_print//lib/prettier_print/single_line.rb#41 + def flush; end + + # Opens a block for grouping objects to be pretty printed. + # + # Arguments: + # * +indent+ - noop argument. Present for compatibility. + # * +open_obj+ - text appended before the &block. Default is '' + # * +close_obj+ - text appended after the &block. Default is '' + # * +open_width+ - noop argument. Present for compatibility. + # * +close_width+ - noop argument. Present for compatibility. + # + # source://prettier_print//lib/prettier_print/single_line.rb#90 + def group(_indent = T.unsafe(nil), open_object = T.unsafe(nil), close_object = T.unsafe(nil), _open_width = T.unsafe(nil), _close_width = T.unsafe(nil)); end + + # Effectively unnecessary, but here for compatibility. + # + # source://prettier_print//lib/prettier_print/single_line.rb#113 + def if_break; end + + # Also effectively unnecessary, but here for compatibility. + # + # source://prettier_print//lib/prettier_print/single_line.rb#118 + def if_flat; end + + # A noop that immediately yields. + # + # source://prettier_print//lib/prettier_print/single_line.rb#122 + def indent; end + + # Changes the target output buffer to the line suffix output buffer which + # will get flushed at the end of printing. + # + # source://prettier_print//lib/prettier_print/single_line.rb#128 + def line_suffix; end + + # A buffer output that wraps any calls to line_suffix that will be flushed + # at the end of printing. + # + # source://prettier_print//lib/prettier_print/single_line.rb#23 + def line_suffixes; end + + # Takes +indent+ arg, but does nothing with it. + # + # Yields to a block. + # + # source://prettier_print//lib/prettier_print/single_line.rb#137 + def nest(_indent); end + + # The output object. It stores rendered text and should respond to <<. + # + # source://prettier_print//lib/prettier_print/single_line.rb#15 + def output; end + + # The current array of contents that the print tree builder methods should + # append to. + # + # source://prettier_print//lib/prettier_print/single_line.rb#19 + def target; end + + # Add +object+ to the text to be output. + # + # +width+ argument is here for compatibility. It is a noop argument. + # + # source://prettier_print//lib/prettier_print/single_line.rb#144 + def text(object = T.unsafe(nil), _width = T.unsafe(nil)); end + + # Immediately trims the output buffer. + # + # source://prettier_print//lib/prettier_print/single_line.rb#74 + def trim; end +end + +# A class that wraps the ability to call #if_flat. The contents of the +# #if_flat block are executed immediately, so effectively this class and the +# #if_break method that triggers it are unnecessary, but they're here to +# maintain compatibility. +# +# source://prettier_print//lib/prettier_print/single_line.rb#106 +class PrettierPrint::SingleLine::IfBreakBuilder + # source://prettier_print//lib/prettier_print/single_line.rb#107 + def if_flat; end +end + +# Since all of the instances here are the same, we can reuse the same one to +# cut down on allocations. +# +# source://prettier_print//lib/prettier_print.rb#270 +PrettierPrint::TRIM = T.let(T.unsafe(nil), PrettierPrint::Trim) + +# A node in the print tree that represents plain content that cannot be broken +# up (by default this assumes strings, but it can really be anything). +# +# source://prettier_print//lib/prettier_print.rb#239 +class PrettierPrint::Text + # @return [Text] a new instance of Text + # + # source://prettier_print//lib/prettier_print.rb#242 + def initialize; end + + # source://prettier_print//lib/prettier_print.rb#247 + def add(object: T.unsafe(nil), width: T.unsafe(nil)); end + + # Returns the value of attribute objects. + # + # source://prettier_print//lib/prettier_print.rb#240 + def objects; end + + # source://prettier_print//lib/prettier_print.rb#252 + def pretty_print(q); end + + # Returns the value of attribute width. + # + # source://prettier_print//lib/prettier_print.rb#240 + def width; end +end + +# A node in the print tree that represents trimming all of the indentation of +# the current line, in the rare case that you need to ignore the indentation +# that you've already created. This node should be placed after a Breakable. +# +# source://prettier_print//lib/prettier_print.rb#262 +class PrettierPrint::Trim + # source://prettier_print//lib/prettier_print.rb#263 + def pretty_print(q); end +end diff --git a/sorbet/rbi/gems/racc@1.7.1.rbi b/sorbet/rbi/gems/racc@1.7.1.rbi new file mode 100644 index 00000000..d01a4f51 --- /dev/null +++ b/sorbet/rbi/gems/racc@1.7.1.rbi @@ -0,0 +1,161 @@ +# 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`. + +# source://racc//lib/racc/parser.rb#23 +ParseError = Racc::ParseError + +# source://racc//lib/racc/info.rb#16 +Racc::Copyright = T.let(T.unsafe(nil), String) + +# source://racc//lib/racc/parser.rb#186 +class Racc::Parser + # source://racc//lib/racc/parser.rb#281 + def _racc_do_parse_rb(arg, in_debug); end + + # source://racc//lib/racc/parser.rb#481 + def _racc_do_reduce(arg, act); end + + # common + # + # source://racc//lib/racc/parser.rb#384 + def _racc_evalact(act, arg); end + + # source://racc//lib/racc/parser.rb#234 + def _racc_init_sysvars; end + + # source://racc//lib/racc/parser.rb#222 + def _racc_setup; end + + # source://racc//lib/racc/parser.rb#331 + def _racc_yyparse_rb(recv, mid, arg, c_debug); end + + # source://racc//lib/racc/parser.rb#264 + def do_parse; end + + # The method to fetch next token. + # If you use #do_parse method, you must implement #next_token. + # + # The format of return value is [TOKEN_SYMBOL, VALUE]. + # +token-symbol+ is represented by Ruby's symbol by default, e.g. :IDENT + # for 'IDENT'. ";" (String) for ';'. + # + # The final symbol (End of file) must be false. + # + # @raise [NotImplementedError] + # + # source://racc//lib/racc/parser.rb#277 + def next_token; end + + # This method is called when a parse error is found. + # + # ERROR_TOKEN_ID is an internal ID of token which caused error. + # You can get string representation of this ID by calling + # #token_to_str. + # + # ERROR_VALUE is a value of error token. + # + # value_stack is a stack of symbol values. + # DO NOT MODIFY this object. + # + # This method raises ParseError by default. + # + # If this method returns, parsers enter "error recovering mode". + # + # @raise [ParseError] + # + # source://racc//lib/racc/parser.rb#537 + def on_error(t, val, vstack); end + + # source://racc//lib/racc/parser.rb#586 + def racc_accept; end + + # source://racc//lib/racc/parser.rb#591 + def racc_e_pop(state, tstack, vstack); end + + # source://racc//lib/racc/parser.rb#598 + def racc_next_state(curstate, state); end + + # source://racc//lib/racc/parser.rb#604 + def racc_print_stacks(t, v); end + + # source://racc//lib/racc/parser.rb#613 + def racc_print_states(s); end + + # For debugging output + # + # source://racc//lib/racc/parser.rb#560 + def racc_read_token(t, tok, val); end + + # source://racc//lib/racc/parser.rb#573 + def racc_reduce(toks, sim, tstack, vstack); end + + # source://racc//lib/racc/parser.rb#567 + def racc_shift(tok, tstack, vstack); end + + # source://racc//lib/racc/parser.rb#620 + def racc_token2str(tok); end + + # Convert internal ID of token symbol to the string. + # + # source://racc//lib/racc/parser.rb#626 + def token_to_str(t); end + + # Exit parser. + # Return value is +Symbol_Value_Stack[0]+. + # + # source://racc//lib/racc/parser.rb#550 + def yyaccept; end + + # Leave error recovering mode. + # + # source://racc//lib/racc/parser.rb#555 + def yyerrok; end + + # Enter error recovering mode. + # This method does not call #on_error. + # + # source://racc//lib/racc/parser.rb#544 + def yyerror; end + + # source://racc//lib/racc/parser.rb#326 + def yyparse(recv, mid); end + + class << self + # source://racc//lib/racc/parser.rb#218 + def racc_runtime_type; end + end +end + +# source://racc//lib/racc/parser.rb#207 +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) + +# source://racc//lib/racc/parser.rb#209 +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) + +# source://racc//lib/racc/parser.rb#189 +Racc::Parser::Racc_Runtime_Core_Version_R = T.let(T.unsafe(nil), String) + +# source://racc//lib/racc/parser.rb#210 +Racc::Parser::Racc_Runtime_Type = T.let(T.unsafe(nil), String) + +# source://racc//lib/racc/parser.rb#188 +Racc::Parser::Racc_Runtime_Version = T.let(T.unsafe(nil), String) + +# source://racc//lib/racc/parser.rb#208 +Racc::Parser::Racc_YY_Parse_Method = T.let(T.unsafe(nil), Symbol) + +# source://racc//lib/racc/parser.rb#183 +Racc::Racc_No_Extensions = T.let(T.unsafe(nil), FalseClass) + +# source://racc//lib/racc/info.rb#14 +Racc::VERSION = T.let(T.unsafe(nil), String) + +# source://racc//lib/racc/info.rb#15 +Racc::Version = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/rake@13.0.6.rbi b/sorbet/rbi/gems/rake@13.0.6.rbi index 245e6df1..0202f06d 100644 --- a/sorbet/rbi/gems/rake@13.0.6.rbi +++ b/sorbet/rbi/gems/rake@13.0.6.rbi @@ -555,6 +555,36 @@ module Rake::DSL private + # source://rake//lib/rake/file_utils_ext.rb#34 + def cd(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def chdir(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def chmod(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def chmod_R(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def chown(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def chown_R(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def copy(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def cp(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def cp_lr(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def cp_r(*args, **options, &block); end + # Describes the next rake task. Duplicate descriptions are discarded. # Descriptions are shown with rake -T (up to the first # sentence) and rake -D (the entire description). @@ -616,6 +646,39 @@ module Rake::DSL # source://rake//lib/rake/dsl_definition.rb#183 def import(*fns); end + # source://rake//lib/rake/file_utils_ext.rb#34 + def install(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def link(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def ln(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def ln_s(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def ln_sf(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def ln_sr(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def makedirs(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def mkdir(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def mkdir_p(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def mkpath(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def move(*args, **options, &block); end + # Declare a task that performs its prerequisites in # parallel. Multitasks does *not* guarantee that its prerequisites # will execute in any given order (which is obvious when you think @@ -627,6 +690,9 @@ module Rake::DSL # source://rake//lib/rake/dsl_definition.rb#112 def multitask(*args, &block); end + # source://rake//lib/rake/file_utils_ext.rb#34 + def mv(*args, **options, &block); end + # Create a new rake namespace and use it for evaluating the given # block. Returns a NameSpace object that can be used to lookup # tasks defined in the namespace. @@ -649,6 +715,39 @@ module Rake::DSL # source://rake//lib/rake/dsl_definition.rb#135 def namespace(name = T.unsafe(nil), &block); end + # source://rake//lib/rake/file_utils_ext.rb#77 + def nowrite(value = T.unsafe(nil)); end + + # source://rake//lib/rake/file_utils_ext.rb#123 + def rake_check_options(options, *optdecl); end + + # source://rake//lib/rake/file_utils_ext.rb#116 + def rake_output_message(message); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def remove(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def rm(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def rm_f(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def rm_r(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def rm_rf(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def rmdir(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def rmtree(*args, **options, &block); end + + # source://rake//lib/rake/file_utils.rb#100 + def ruby(*args, **options, &block); end + # Declare a rule for auto-tasks. # # Example: @@ -659,6 +758,21 @@ module Rake::DSL # source://rake//lib/rake/dsl_definition.rb#151 def rule(*args, &block); end + # source://rake//lib/rake/file_utils.rb#112 + def safe_ln(*args, **options); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def safe_unlink(*args, **options, &block); end + + # source://rake//lib/rake/file_utils.rb#43 + def sh(*cmd, &block); end + + # source://rake//lib/rake/file_utils.rb#128 + def split_all(path); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def symlink(*args, **options, &block); end + # :call-seq: # task(task_name) # task(task_name: dependencies) @@ -692,6 +806,15 @@ module Rake::DSL # # source://rake//lib/rake/dsl_definition.rb#59 def task(*args, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#34 + def touch(*args, **options, &block); end + + # source://rake//lib/rake/file_utils_ext.rb#53 + def verbose(value = T.unsafe(nil)); end + + # source://rake//lib/rake/file_utils_ext.rb#107 + def when_writing(msg = T.unsafe(nil)); end end # Default Rakefile loader used by +import+. @@ -725,6 +848,13 @@ class Rake::EarlyTime # source://rake//lib/rake/early_time.rb#16 def to_s; end + + class << self + private + + def allocate; end + def new(*_arg0); end + end end # A FileCreationTask is a file task that when used as a dependency will be @@ -732,7 +862,7 @@ end # not re-triggered if any of its dependencies are newer, nor does trigger # any rebuilds of tasks that depend on it whenever it is updated. # -# source://rake//lib/rake/file_creation_task.rb#13 +# source://rake//lib/rake/file_creation_task.rb#12 class Rake::FileCreationTask < ::Rake::FileTask # Is this file task needed? Yes if it doesn't exist. # @@ -1528,6 +1658,9 @@ module Rake::FileUtilsExt # source://rake//lib/rake/file_utils_ext.rb#34 def ln_sf(*args, **options, &block); end + # source://rake//lib/rake/file_utils_ext.rb#34 + def ln_sr(*args, **options, &block); end + # source://rake//lib/rake/file_utils_ext.rb#34 def makedirs(*args, **options, &block); end @@ -1757,6 +1890,13 @@ class Rake::LateTime # source://rake//lib/rake/late_time.rb#12 def to_s; end + + class << self + private + + def allocate; end + def new(*_arg0); end + end end # Polylithic linked list structure used to implement several data diff --git a/sorbet/rbi/gems/regexp_parser@2.7.0.rbi b/sorbet/rbi/gems/regexp_parser@2.8.1.rbi similarity index 87% rename from sorbet/rbi/gems/regexp_parser@2.7.0.rbi rename to sorbet/rbi/gems/regexp_parser@2.8.1.rbi index b191ad7d..e10d9b8d 100644 --- a/sorbet/rbi/gems/regexp_parser@2.7.0.rbi +++ b/sorbet/rbi/gems/regexp_parser@2.8.1.rbi @@ -22,7 +22,7 @@ end # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#6 Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative -# A sequence of expressions, used by Alternation as one of its alternative. +# A sequence of expressions, used by Alternation as one of its alternatives. # # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#3 class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence @@ -102,77 +102,80 @@ class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::B def human_name; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#86 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#64 module Regexp::Expression::Assertion; end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#87 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#65 class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148 def match_length; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#89 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#67 class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#19 def human_name; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#92 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#70 class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#20 def human_name; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#90 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#68 class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#21 def human_name; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#93 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#71 class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#22 def human_name; end end -# TODO: unify name with token :backref, one way or the other, in v3.0.0 +# alias for symmetry between token symbol and Expression class name # -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#74 +Regexp::Expression::Backref = Regexp::Expression::Backreference + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#2 module Regexp::Expression::Backreference; end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3 class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#155 def match_length; end # Returns the value of attribute referenced_expression. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#5 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4 def referenced_expression; end # Sets the attribute referenced_expression # # @param value the value to set the attribute referenced_expression to. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#5 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4 def referenced_expression=(_arg0); end - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24 - def referential?; end - private - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#7 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#6 def initialize_copy(orig); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#140 + def referential?; end + end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#39 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34 class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base # @return [Name] a new instance of Name # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#38 def initialize(token, options = T.unsafe(nil)); end # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23 @@ -180,39 +183,39 @@ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backrefere # Returns the value of attribute name. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35 def name; end # Returns the value of attribute name. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35 def reference; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#55 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50 class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24 def human_name; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#67 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#62 class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name # @return [NameRecursionLevel] a new instance of NameRecursionLevel # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#70 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#65 def initialize(token, options = T.unsafe(nil)); end # Returns the value of attribute recursion_level. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#68 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#63 def recursion_level; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#29 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24 class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base # @return [Number] a new instance of Number # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#33 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#28 def initialize(token, options = T.unsafe(nil)); end # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25 @@ -220,52 +223,52 @@ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backrefe # Returns the value of attribute number. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25 def number; end # Returns the value of attribute number. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25 def reference; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49 class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27 def human_name; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#51 class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28 def human_name; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#58 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#53 class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#61 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56 def initialize(token, options = T.unsafe(nil)); end # Returns the value of attribute recursion_level. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#59 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54 def recursion_level; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49 +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#44 class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number # Returns the value of attribute effective_number. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45 def effective_number; end # Sets the attribute effective_number # # @param value the value to set the attribute effective_number to. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45 def effective_number=(_arg0); end # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26 @@ -273,7 +276,7 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression:: # Returns the value of attribute effective_number. # - # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50 + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45 def reference; end end @@ -300,7 +303,7 @@ class Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25 def ascii_classes?; end - # source://regexp_parser//lib/regexp_parser/expression/base.rb#67 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#60 def attributes; end # @return [Boolean] @@ -314,6 +317,12 @@ class Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def conditional_level=(_arg0); end + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling=(_arg0); end + # @return [Boolean] # # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20 @@ -336,7 +345,7 @@ class Regexp::Expression::Base # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/base.rb#54 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#47 def greedy?; end # @return [Boolean] @@ -351,7 +360,7 @@ class Regexp::Expression::Base # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/base.rb#58 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#51 def lazy?; end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -383,7 +392,7 @@ class Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3 def multiline?; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#13 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 def nesting_level; end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -392,28 +401,40 @@ class Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def options=(_arg0); end + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent=(_arg0); end + # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/base.rb#63 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#56 def possessive?; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#13 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 def quantifier; end - # source://regexp_parser//lib/regexp_parser/expression/base.rb#24 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#17 def quantify(*args); end # Deprecated. Prefer `#repetitions` which has a more uniform interface. # - # source://regexp_parser//lib/regexp_parser/expression/base.rb#33 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#26 def quantity; end # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/base.rb#58 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#51 def reluctant?; end - # source://regexp_parser//lib/regexp_parser/expression/base.rb#38 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#31 def repetitions; end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -506,10 +527,10 @@ class Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def text=(_arg0); end - # source://regexp_parser//lib/regexp_parser/expression/base.rb#67 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#60 def to_h; end - # source://regexp_parser//lib/regexp_parser/expression/base.rb#16 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#9 def to_re(format = T.unsafe(nil)); end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -540,18 +561,13 @@ class Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30 def unicode_classes?; end - # source://regexp_parser//lib/regexp_parser/expression/base.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/base.rb#21 def unquantified_clone; end # @return [Boolean] # # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14 def x?; end - - private - - # source://regexp_parser//lib/regexp_parser/expression/base.rb#9 - def initialize_copy(orig); end end # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#2 @@ -609,7 +625,7 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 def negative?; end - # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#23 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#15 def parts; end end @@ -636,12 +652,12 @@ Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::Ch # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#3 class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression - # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#9 + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#8 def <<(exp); end # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#15 + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#14 def complete?; end # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31 @@ -650,12 +666,9 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 def match_length; end - # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#19 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#16 def parts; end - # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#4 - def starts_at; end - # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#4 def ts; end end @@ -709,12 +722,17 @@ class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterT class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#33 def human_name; end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#130 + def comment?; end + end end # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2 module Regexp::Expression::Conditional; end -# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#29 +# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#25 class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34 def human_name; end @@ -746,39 +764,39 @@ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10 def referenced_expression=(_arg0); end - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#24 - def referential?; end - private # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#19 def initialize_copy(orig); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#141 + def referential?; end + end end -# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#31 +# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#27 class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#30 def <<(exp); end # @raise [TooManyBranches] # - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38 - def add_sequence(active_opts = T.unsafe(nil)); end + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34 + def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end # @raise [TooManyBranches] # - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38 - def branch(active_opts = T.unsafe(nil)); end + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34 + def branch(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50 def branches; end - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#46 def condition; end - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#45 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41 def condition=(exp); end # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36 @@ -787,33 +805,33 @@ class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexp # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131 def match_length; end - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#66 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#17 def parts; end - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54 def reference; end # Returns the value of attribute referenced_expression. # - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28 def referenced_expression; end # Sets the attribute referenced_expression # # @param value the value to set the attribute referenced_expression to. # - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28 def referenced_expression=(_arg0); end - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#62 - def referential?; end - private - # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#70 + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58 def initialize_copy(orig); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#142 + def referential?; end + end end # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#3 @@ -824,117 +842,120 @@ class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error def initialize; end end -# TODO: unify naming with Token::Escape, one way or the other, in v3.0.0 +# alias for symmetry between Token::* and Expression::* # -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#101 +Regexp::Expression::Escape = Regexp::Expression::EscapeSequence + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#2 module Regexp::Expression::EscapeSequence; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#64 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#63 class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#65 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#64 def char; end private - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#71 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#70 def control_sequence_to_s(control_sequence); end - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#76 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#75 def meta_char_to_codepoint(meta_char); end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#28 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#27 class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#28 class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#4 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3 class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#10 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#9 def char; end - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#5 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#4 def codepoint; end # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 def match_length; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#30 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29 class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#38 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#37 class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#40 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#39 class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base # @raise [NoMethodError] # - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#41 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#40 def char; end - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#49 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#48 def chars; end # @raise [NoMethodError] # - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#45 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#44 def codepoint; end - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#53 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#52 def codepoints; end # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#164 def match_length; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#82 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#81 class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#83 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#82 def codepoint; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#31 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#30 class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#37 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#36 class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#21 class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#23 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22 def char; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#88 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#87 class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#89 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#88 def codepoint; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#94 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#93 class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#95 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#94 def codepoint; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#32 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#31 class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#58 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#57 class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base - # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#59 + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#58 def char; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#33 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#32 class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#34 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#33 class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#35 +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#34 class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2 @@ -946,6 +967,11 @@ class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base # # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#3 def quantify(*_args); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#135 + def decorative?; end + end end # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#2 @@ -954,87 +980,80 @@ module Regexp::Expression::Group; end # Special case. Absence group can match 0.. chars, irrespective of content. # TODO: in theory, they *can* exclude match lengths with `.`: `(?~.{3})` # -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#34 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#19 class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#172 def match_length; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#35 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#20 class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#3 class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#8 - def capturing?; end - - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#10 - def comment?; end - - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#4 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#18 def parts; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#55 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#40 class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#59 - def capturing?; end - # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#37 def human_name; end # Returns the value of attribute number. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#56 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 def identifier; end # Returns the value of attribute number. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#56 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 def number; end # Sets the attribute number # # @param value the value to set the attribute number to. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#56 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 def number=(_arg0); end # Returns the value of attribute number_at_level. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#56 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 def number_at_level; end # Sets the attribute number_at_level # # @param value the value to set the attribute number_at_level to. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#56 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 def number_at_level=(_arg0); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#126 + def capturing?; end + end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#77 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#60 class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#82 - def comment?; end - - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#78 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#20 def parts; end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#131 + def comment?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#136 + def decorative?; end + end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#62 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#45 class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture # @return [Named] a new instance of Named # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#66 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#49 def initialize(token, options = T.unsafe(nil)); end # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#38 @@ -1042,66 +1061,66 @@ class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture # Returns the value of attribute name. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#63 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46 def identifier; end # Returns the value of attribute name. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#63 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46 def name; end private - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#71 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#54 def initialize_copy(orig); end end # TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no # longer inherit from Group because it is effectively a terminal expression. # -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#38 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#23 class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base # Returns the value of attribute option_changes. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#39 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24 def option_changes; end # Sets the attribute option_changes # # @param value the value to set the attribute option_changes to. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#39 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24 def option_changes=(_arg0); end - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#31 def quantify(*args); end private - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#26 def initialize_copy(orig); end end -# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#13 +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#6 class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base # @return [Passive] a new instance of Passive # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#16 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#9 def initialize(*_arg0); end # Sets the attribute implicit # # @param value the value to set the attribute implicit to. # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#14 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#7 def implicit=(_arg0); end # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#29 + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#14 def implicit?; end - # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#21 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#19 def parts; end end @@ -1132,6 +1151,12 @@ end # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#85 Regexp::Expression::MatchLength = Regexp::MatchLength +# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#14 +Regexp::Expression::Nonposixclass = Regexp::Expression::PosixClass + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#121 +Regexp::Expression::Nonproperty = Regexp::Expression::UnicodeProperty + # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2 class Regexp::Expression::PosixClass < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 @@ -1146,6 +1171,16 @@ class Regexp::Expression::PosixClass < ::Regexp::Expression::Base def negative?; end end +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#13 +Regexp::Expression::Posixclass = Regexp::Expression::PosixClass + +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#120 +Regexp::Expression::Property = Regexp::Expression::UnicodeProperty + # TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and # call super in #initialize, but raise in #quantifier= and #quantify, # or introduce an Expression::Quantifiable intermediate class. @@ -1158,7 +1193,7 @@ class Regexp::Expression::Quantifier # @return [Quantifier] a new instance of Quantifier # - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#13 + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11 def initialize(*args); end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -1167,10 +1202,16 @@ class Regexp::Expression::Quantifier # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def conditional_level=(_arg0); end - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#35 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 def greedy?; end - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#35 + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 def lazy?; end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -1179,22 +1220,16 @@ class Regexp::Expression::Quantifier # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def level=(_arg0); end - # Returns the value of attribute max. - # - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11 + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#42 def max; end - # Returns the value of attribute min. - # - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11 + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#38 def min; end - # Returns the value of attribute mode. - # - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11 + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#46 def mode; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#13 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 def nesting_level; end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -1203,13 +1238,25 @@ class Regexp::Expression::Quantifier # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def options=(_arg0); end - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#35 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 def possessive?; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#13 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 def quantifier; end - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#35 + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 def reluctant?; end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -1230,7 +1277,7 @@ class Regexp::Expression::Quantifier # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def text=(_arg0); end - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#23 + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#19 def to_h; end # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 @@ -1253,11 +1300,11 @@ class Regexp::Expression::Quantifier private - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#44 - def deprecated_old_init(token, text, min, max, mode = T.unsafe(nil)); end + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#52 + def deprecated_old_init(token, text, _min, _max, _mode = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#59 - def minmax; end + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#64 + def derived_data; end end # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#9 @@ -1284,12 +1331,9 @@ end # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8 class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27 - def quantify(*args); end - - # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22 - def starts_at; end + def quantify(token, *args); end - # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22 + # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23 def ts; end class << self @@ -1302,11 +1346,11 @@ end # # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#3 class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression - # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#13 + # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#12 def <<(exp); end - # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#17 - def add_sequence(active_opts = T.unsafe(nil)); end + # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#16 + def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 def operands; end @@ -1314,45 +1358,68 @@ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpressio # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 def operator; end - # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#21 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#22 def parts; end # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 def sequences; end - # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#8 - def starts_at; end - # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#8 def ts; end end +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#25 +Regexp::Expression::Set = Regexp::Expression::CharacterSet + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#2 module Regexp::Expression::Shared mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods # Deep-compare two expressions for equality. # - # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#98 + # When changing the conditions, please make sure to update + # #pretty_print_instance_variables so that it includes all relevant values. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101 def ==(other); end # Deep-compare two expressions for equality. # - # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#98 + # When changing the conditions, please make sure to update + # #pretty_print_instance_variables so that it includes all relevant values. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101 def ===(other); end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#42 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#51 def base_length; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#75 + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#124 + def capturing?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#96 def coded_offset; end + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#128 + def comment?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#133 + def decorative?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#47 + def ends_at(include_quantifier = T.unsafe(nil)); end + # Deep-compare two expressions for equality. # - # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#98 + # When changing the conditions, please make sure to update + # #pretty_print_instance_variables so that it includes all relevant values. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101 def eql?(other); end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#46 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#55 def full_length; end # default implementation, e.g. "atomic group", "hex escape", "word type", .. @@ -1360,6 +1427,9 @@ module Regexp::Expression::Shared # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#4 def human_name; end + # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#3 + def inspect; end + # Test if this expression has the given test_token, and optionally a given # test_type. # @@ -1383,10 +1453,10 @@ module Regexp::Expression::Shared # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36 def is?(test_token, test_type = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#87 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#100 def nesting_level=(lvl); end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#71 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#92 def offset; end # Test if this expression matches an entry in the given scope spec. @@ -1430,43 +1500,80 @@ module Regexp::Expression::Shared # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#67 + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#111 def optional?; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#55 + # default implementation + # + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#4 def parts; end + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#84 + def pre_quantifier_decoration(expression_format = T.unsafe(nil)); end + + # Make pretty-print work despite #inspect implementation. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#12 + def pretty_print(q); end + + # Called by pretty_print (ruby/pp) and #inspect. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#17 + def pretty_print_instance_variables; end + # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#63 + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#115 def quantified?; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#93 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#106 def quantifier=(qtf); end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#59 - def quantifier_affix(expression_format); end + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#88 + def quantifier_affix(expression_format = T.unsafe(nil)); end - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#83 + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#138 def referential?; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#38 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#43 def starts_at; end - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#79 + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#120 def terminal?; end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#50 + # #to_s reproduces the original source, as an unparser would. + # + # It takes an optional format argument. + # + # Example: + # + # lit = Regexp::Parser.parse(/a +/x)[0] + # + # lit.to_s # => 'a+' # default; with quantifier + # lit.to_s(:full) # => 'a+' # default; with quantifier + # lit.to_s(:base) # => 'a' # without quantifier + # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations + # + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72 def to_s(format = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#50 + # #to_s reproduces the original source, as an unparser would. + # + # It takes an optional format argument. + # + # Example: + # + # lit = Regexp::Parser.parse(/a +/x)[0] + # + # lit.to_s # => 'a+' # default; with quantifier + # lit.to_s(:full) # => 'a+' # default; with quantifier + # lit.to_s(:base) # => 'a' # without quantifier + # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations + # + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72 def to_str(format = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#39 + # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#37 def token_class; end # Test if this expression has the given test_type, which can be either @@ -1485,12 +1592,15 @@ module Regexp::Expression::Shared private - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#17 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#18 def init_from_token_and_options(token, options = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/shared.rb#31 + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#32 def initialize_copy(orig); end + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#10 + def intersperse(expressions, separator); end + class << self # @private # @@ -1503,6 +1613,12 @@ end # # source://regexp_parser//lib/regexp_parser/expression/shared.rb#3 module Regexp::Expression::Shared::ClassMethods + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#125 + def capturing?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#129 + def comment?; end + # Convenience method to init a valid Expression without a Regexp::Token # # @raise [ArgumentError] @@ -1513,6 +1629,15 @@ module Regexp::Expression::Shared::ClassMethods # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#15 def construct_defaults; end + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#134 + def decorative?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#139 + def referential?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#121 + def terminal?; end + # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#25 def token_class; end end @@ -1526,28 +1651,30 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#7 def initialize(token, options = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#18 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#20 def <<(exp); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def [](*args, &block); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def at(*args, &block); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#34 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#33 def dig(*indices); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def each(*args, &block); end - # Iterates over the expressions of this expression as an array, passing - # the expression and its index within its parent to the given block. + # Traverses the expression, passing each recursive child to the + # given block. + # If the block takes two arguments, the indices of the children within + # their parents are also passed to it. # - # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#39 + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#8 def each_expression(include_self = T.unsafe(nil), &block); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def empty?(*args, &block); end # Returns the value of attribute expressions. @@ -1562,35 +1689,38 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 def expressions=(_arg0); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#50 + def extract_quantifier_target(quantifier_description); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def fetch(*args, &block); end # Returns a new array with the results of calling the given block once # for every expression. If a block is not given, returns an array with # each expression and its level index as an array. # - # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#53 - def flat_map(include_self = T.unsafe(nil)); end + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#56 + def flat_map(include_self = T.unsafe(nil), &block); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def index(*args, &block); end # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#118 def inner_match_length; end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def join(*args, &block); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def last(*args, &block); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def length(*args, &block); end # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#111 def match_length; end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#44 + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#21 def parts; end # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102 @@ -1599,15 +1729,10 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102 def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#40 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#39 def te; end - # @return [Boolean] - # - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#55 - def terminal?; end - - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#48 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#43 def to_h; end # Traverses the subexpression (depth-first, pre-order) and calls the given @@ -1623,10 +1748,10 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base # # Returns self. # - # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#16 + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32 def traverse(include_self = T.unsafe(nil), &block); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28 + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 def values_at(*args, &block); end # Traverses the subexpression (depth-first, pre-order) and calls the given @@ -1642,9 +1767,17 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base # # Returns self. # - # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#16 + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32 def walk(include_self = T.unsafe(nil), &block); end + protected + + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#66 + def each_expression_with_index(&block); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#73 + def each_expression_without_index(&block); end + private # Override base method to clone the expressions as well. @@ -1652,266 +1785,266 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13 def initialize_copy(orig); end - # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#61 - def intersperse(expressions, separator); end + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#122 + def terminal?; end + end end -# TODO: unify name with token :property, one way or the other, in v3.0.0 -# -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#2 module Regexp::Expression::UnicodeProperty; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#112 class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#17 class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18 class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#36 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#35 class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19 class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#37 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#36 class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3 class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 def match_length; end - # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#9 + # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#8 def name; end # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#5 + # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4 def negative?; end - # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#13 + # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#12 def shortcut; end end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20 class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#117 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#116 class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21 class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#101 module Regexp::Expression::UnicodeProperty::Codepoint; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#104 class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#103 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102 class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#106 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105 class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#107 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#106 class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108 class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#107 class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#110 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109 class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#114 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113 class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22 class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#115 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#114 class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23 class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#38 module Regexp::Expression::UnicodeProperty::Letter; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#41 class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#40 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39 class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42 class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#45 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#44 class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46 class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#48 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47 class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#45 class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#44 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43 class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24 class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#50 module Regexp::Expression::UnicodeProperty::Mark; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#54 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#53 class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#52 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51 class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#55 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#54 class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#58 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57 class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#55 class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56 class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#34 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#33 class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#60 module Regexp::Expression::UnicodeProperty::Number; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#64 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#63 class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#62 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61 class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#64 class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65 class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#67 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66 class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25 class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26 class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#69 module Regexp::Expression::UnicodeProperty::Punctuation; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#72 class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#71 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70 class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#77 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#76 class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73 class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74 class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78 class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#77 class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#76 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75 class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#80 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79 class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#116 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#115 class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#82 module Regexp::Expression::UnicodeProperty::Separator; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#86 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#85 class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#84 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83 class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87 class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#89 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88 class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#86 class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#28 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27 class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#91 module Regexp::Expression::UnicodeProperty::Symbol; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#95 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#94 class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#93 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92 class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#96 class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#96 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#95 class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97 class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#99 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98 class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#28 class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#30 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29 class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#32 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31 class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31 +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#30 class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end -# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#10 +# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#11 class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#42 def human_name; end - # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#11 + # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#12 def merge(exp); end end @@ -1949,13 +2082,13 @@ class Regexp::Lexer # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc' # c.f. #break_literal. # - # source://regexp_parser//lib/regexp_parser/lexer.rb#135 + # source://regexp_parser//lib/regexp_parser/lexer.rb#143 def break_codepoint_list(token); end # called by scan to break a literal run that is longer than one character # into two separate tokens when it is followed by a quantifier # - # source://regexp_parser//lib/regexp_parser/lexer.rb#115 + # source://regexp_parser//lib/regexp_parser/lexer.rb#123 def break_literal(token); end # Returns the value of attribute collect_tokens. @@ -1982,10 +2115,10 @@ class Regexp::Lexer # source://regexp_parser//lib/regexp_parser/lexer.rb#87 def conditional_nesting=(_arg0); end - # source://regexp_parser//lib/regexp_parser/lexer.rb#102 + # source://regexp_parser//lib/regexp_parser/lexer.rb#106 def descend(type, token); end - # source://regexp_parser//lib/regexp_parser/lexer.rb#154 + # source://regexp_parser//lib/regexp_parser/lexer.rb#162 def merge_condition(current, last); end # Returns the value of attribute nesting. @@ -2204,14 +2337,13 @@ end # source://regexp_parser//lib/regexp_parser/version.rb#2 class Regexp::Parser include ::Regexp::Expression - include ::Regexp::Expression::UnicodeProperty # source://regexp_parser//lib/regexp_parser/parser.rb#25 def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end private - # source://regexp_parser//lib/regexp_parser/parser.rb#574 + # source://regexp_parser//lib/regexp_parser/parser.rb#573 def active_opts; end # source://regexp_parser//lib/regexp_parser/parser.rb#99 @@ -2224,7 +2356,7 @@ class Regexp::Parser # an instance of Backreference::Number, its #referenced_expression is set to # the instance of Group::Capture that it refers to via its number. # - # source://regexp_parser//lib/regexp_parser/parser.rb#581 + # source://regexp_parser//lib/regexp_parser/parser.rb#580 def assign_referenced_expressions; end # source://regexp_parser//lib/regexp_parser/parser.rb#227 @@ -2245,13 +2377,13 @@ class Regexp::Parser # source://regexp_parser//lib/regexp_parser/parser.rb#56 def captured_group_counts=(_arg0); end - # source://regexp_parser//lib/regexp_parser/parser.rb#570 + # source://regexp_parser//lib/regexp_parser/parser.rb#569 def close_completed_character_set_range; end # source://regexp_parser//lib/regexp_parser/parser.rb#210 def close_group; end - # source://regexp_parser//lib/regexp_parser/parser.rb#538 + # source://regexp_parser//lib/regexp_parser/parser.rb#537 def close_set; end # source://regexp_parser//lib/regexp_parser/parser.rb#269 @@ -2283,28 +2415,28 @@ class Regexp::Parser # source://regexp_parser//lib/regexp_parser/parser.rb#60 def extract_options(input, options); end - # source://regexp_parser//lib/regexp_parser/parser.rb#347 + # source://regexp_parser//lib/regexp_parser/parser.rb#349 def free_space(token); end # source://regexp_parser//lib/regexp_parser/parser.rb#114 def group(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#511 + # source://regexp_parser//lib/regexp_parser/parser.rb#508 def increase_group_level(exp); end - # source://regexp_parser//lib/regexp_parser/parser.rb#549 + # source://regexp_parser//lib/regexp_parser/parser.rb#548 def intersection(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#362 + # source://regexp_parser//lib/regexp_parser/parser.rb#360 def keep(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#366 + # source://regexp_parser//lib/regexp_parser/parser.rb#364 def literal(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#370 + # source://regexp_parser//lib/regexp_parser/parser.rb#368 def meta(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#534 + # source://regexp_parser//lib/regexp_parser/parser.rb#533 def negate_set; end # source://regexp_parser//lib/regexp_parser/parser.rb#299 @@ -2340,7 +2472,7 @@ class Regexp::Parser # source://regexp_parser//lib/regexp_parser/parser.rb#165 def open_group(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#529 + # source://regexp_parser//lib/regexp_parser/parser.rb#526 def open_set(token); end # source://regexp_parser//lib/regexp_parser/parser.rb#130 @@ -2361,16 +2493,16 @@ class Regexp::Parser # source://regexp_parser//lib/regexp_parser/parser.rb#76 def parse_token(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#392 + # source://regexp_parser//lib/regexp_parser/parser.rb#390 def posixclass(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#399 + # source://regexp_parser//lib/regexp_parser/parser.rb#397 def property(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#480 + # source://regexp_parser//lib/regexp_parser/parser.rb#478 def quantifier(token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#542 + # source://regexp_parser//lib/regexp_parser/parser.rb#541 def range(token); end # Returns the value of attribute root. @@ -2385,10 +2517,10 @@ class Regexp::Parser # source://regexp_parser//lib/regexp_parser/parser.rb#56 def root=(_arg0); end - # source://regexp_parser//lib/regexp_parser/parser.rb#381 + # source://regexp_parser//lib/regexp_parser/parser.rb#379 def sequence_operation(klass, token); end - # source://regexp_parser//lib/regexp_parser/parser.rb#517 + # source://regexp_parser//lib/regexp_parser/parser.rb#514 def set(token); end # Returns the value of attribute switching_options. @@ -2406,7 +2538,7 @@ class Regexp::Parser # source://regexp_parser//lib/regexp_parser/parser.rb#198 def total_captured_group_count; end - # source://regexp_parser//lib/regexp_parser/parser.rb#553 + # source://regexp_parser//lib/regexp_parser/parser.rb#552 def type(token); end class << self @@ -2429,7 +2561,10 @@ Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/parser.rb#7 class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end -# source://regexp_parser//lib/regexp_parser/parser.rb#397 +# source://regexp_parser//lib/regexp_parser/parser.rb#394 +Regexp::Parser::UP = Regexp::Expression::UnicodeProperty + +# source://regexp_parser//lib/regexp_parser/parser.rb#395 Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty # source://regexp_parser//lib/regexp_parser/parser.rb#15 @@ -2451,26 +2586,26 @@ end # source://regexp_parser//lib/regexp_parser/version.rb#3 Regexp::Parser::VERSION = T.let(T.unsafe(nil), String) -# source://regexp_parser//lib/regexp_parser/scanner.rb#13 +# source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#3 class Regexp::Scanner # Emits an array with the details of the scanned pattern # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2591 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2388 def emit(type, token, text); end # only public for #||= to work on ruby <= 2.5 # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2616 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2413 def literal_run; end # only public for #||= to work on ruby <= 2.5 # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2616 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2413 def literal_run=(_arg0); end # @raise [PrematureEndError] # - # source://regexp_parser//lib/regexp_parser/scanner.rb#84 + # source://regexp_parser//lib/regexp_parser/scanner.rb#24 def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end private @@ -2478,174 +2613,168 @@ class Regexp::Scanner # Appends one or more characters to the literal buffer, to be emitted later # by a call to emit_literal. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2653 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2450 def append_literal(data, ts, te); end # Returns the value of attribute block. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def block; end # Sets the attribute block # # @param value the value to set the attribute block to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def block=(_arg0); end # Returns the value of attribute char_pos. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def char_pos; end # Sets the attribute char_pos # # @param value the value to set the attribute char_pos to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def char_pos=(_arg0); end # Returns the value of attribute collect_tokens. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def collect_tokens; end # Sets the attribute collect_tokens # # @param value the value to set the attribute collect_tokens to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def collect_tokens=(_arg0); end # Returns the value of attribute conditional_stack. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def conditional_stack; end # Sets the attribute conditional_stack # # @param value the value to set the attribute conditional_stack to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def conditional_stack=(_arg0); end # Copy from ts to te from data as text # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2647 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2444 def copy(data, ts, te); end # Emits the literal run collected by calls to the append_literal method. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2658 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2455 def emit_literal; end - # source://regexp_parser//lib/regexp_parser/scanner.rb#2693 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2490 def emit_meta_control_sequence(data, ts, te, token); end - # source://regexp_parser//lib/regexp_parser/scanner.rb#2664 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2461 def emit_options(text); end # Returns the value of attribute free_spacing. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def free_spacing; end # Sets the attribute free_spacing # # @param value the value to set the attribute free_spacing to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def free_spacing=(_arg0); end # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2626 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2423 def free_spacing?(input_object, options); end # Returns the value of attribute group_depth. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def group_depth; end # Sets the attribute group_depth # # @param value the value to set the attribute group_depth to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def group_depth=(_arg0); end # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2638 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 def in_group?; end # @return [Boolean] # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2642 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2439 def in_set?; end # Returns the value of attribute prev_token. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def prev_token; end # Sets the attribute prev_token # # @param value the value to set the attribute prev_token to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def prev_token=(_arg0); end # Returns the value of attribute set_depth. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def set_depth; end # Sets the attribute set_depth # # @param value the value to set the attribute set_depth to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def set_depth=(_arg0); end # Returns the value of attribute spacing_stack. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def spacing_stack; end # Sets the attribute spacing_stack # # @param value the value to set the attribute spacing_stack to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def spacing_stack=(_arg0); end # Returns the value of attribute tokens. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def tokens; end # Sets the attribute tokens # # @param value the value to set the attribute tokens to. # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2620 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2417 def tokens=(_arg0); end - # Centralizes and unifies the handling of validation related - # errors. - # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2702 - def validation_error(type, what, reason = T.unsafe(nil)); end - class << self - # source://regexp_parser//lib/regexp_parser/scanner.rb#2577 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2374 def long_prop_map; end - # source://regexp_parser//lib/regexp_parser/scanner.rb#2581 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2378 def parse_prop_map(name); end - # source://regexp_parser//lib/regexp_parser/scanner.rb#2585 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2382 def posix_classes; end # Scans the given regular expression text, or Regexp object and collects the @@ -2655,100 +2784,105 @@ class Regexp::Scanner # This method may raise errors if a syntax error is encountered. # -------------------------------------------------------------------------- # - # source://regexp_parser//lib/regexp_parser/scanner.rb#80 + # source://regexp_parser//lib/regexp_parser/scanner.rb#20 def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end # lazy-load property maps when first needed # - # source://regexp_parser//lib/regexp_parser/scanner.rb#2573 + # source://regexp_parser//lib/regexp_parser/scanner.rb#2370 def short_prop_map; end end end # Invalid back reference. Used for name a number refs/calls. # -# source://regexp_parser//lib/regexp_parser/scanner.rb#54 +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#44 class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError # @return [InvalidBackrefError] a new instance of InvalidBackrefError # - # source://regexp_parser//lib/regexp_parser/scanner.rb#55 + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#45 def initialize(what, reason); end end # Invalid group. Used for named groups. # -# source://regexp_parser//lib/regexp_parser/scanner.rb#39 +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#29 class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError # @return [InvalidGroupError] a new instance of InvalidGroupError # - # source://regexp_parser//lib/regexp_parser/scanner.rb#40 + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#30 def initialize(what, reason); end end # Invalid groupOption. Used for inline options. # TODO: should become InvalidGroupOptionError in v3.0.0 for consistency # -# source://regexp_parser//lib/regexp_parser/scanner.rb#47 +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#37 class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError # @return [InvalidGroupOption] a new instance of InvalidGroupOption # - # source://regexp_parser//lib/regexp_parser/scanner.rb#48 + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#38 def initialize(option, text); end end # Invalid sequence format. Used for escape sequences, mainly. # -# source://regexp_parser//lib/regexp_parser/scanner.rb#32 +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#22 class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError # @return [InvalidSequenceError] a new instance of InvalidSequenceError # - # source://regexp_parser//lib/regexp_parser/scanner.rb#33 + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#23 def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end end # Unexpected end of pattern # -# source://regexp_parser//lib/regexp_parser/scanner.rb#25 +# source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#3 class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError # @return [PrematureEndError] a new instance of PrematureEndError # - # source://regexp_parser//lib/regexp_parser/scanner.rb#26 + # source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#4 def initialize(where = T.unsafe(nil)); end end # General scanner error (catch all) # -# source://regexp_parser//lib/regexp_parser/scanner.rb#15 +# source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#5 class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end # The POSIX class name was not recognized by the scanner. # -# source://regexp_parser//lib/regexp_parser/scanner.rb#68 +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#58 class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError # - # source://regexp_parser//lib/regexp_parser/scanner.rb#69 - def initialize(text); end + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#59 + def initialize(text, _); end end # The property name was not recognized by the scanner. # -# source://regexp_parser//lib/regexp_parser/scanner.rb#61 +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#51 class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError # - # source://regexp_parser//lib/regexp_parser/scanner.rb#62 - def initialize(name); end + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#52 + def initialize(name, _); end end # Base for all scanner validation errors # -# source://regexp_parser//lib/regexp_parser/scanner.rb#18 -class Regexp::Scanner::ValidationError < ::Regexp::Parser::Error - # @return [ValidationError] a new instance of ValidationError - # - # source://regexp_parser//lib/regexp_parser/scanner.rb#19 - def initialize(reason); end +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#3 +class Regexp::Scanner::ValidationError < ::Regexp::Scanner::ScannerError + class << self + # Centralizes and unifies the handling of validation related errors. + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#5 + def for(type, problem, reason = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#9 + def types; end + end end # After loading all the tokens the map is full. Extract all tokens and types @@ -2919,7 +3053,7 @@ class Regexp::Syntax::Base end # source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8 -Regexp::Syntax::CURRENT = Regexp::Syntax::V3_1_0 +Regexp::Syntax::CURRENT = Regexp::Syntax::V3_2_0 # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6 class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError @@ -2946,6 +3080,17 @@ module Regexp::Syntax::Token; end # source://regexp_parser//lib/regexp_parser/syntax/token.rb#42 Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array) +# alias for symmetry between Token::* and Expression::* +# +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#15 +module Regexp::Syntax::Token::Alternation; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#16 +Regexp::Syntax::Token::Alternation::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#17 +Regexp::Syntax::Token::Alternation::Type = T.let(T.unsafe(nil), Symbol) + # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#3 module Regexp::Syntax::Token::Anchor; end @@ -2982,6 +3127,11 @@ Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#8 Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol) +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#31 +Regexp::Syntax::Token::Backref = Regexp::Syntax::Token::Backreference + # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#3 module Regexp::Syntax::Token::Backreference; end @@ -3066,38 +3216,41 @@ Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#11 Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol) -# TODO: unify naming with RE::EscapeSequence, one way or the other, in v3.0.0 -# -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#3 module Regexp::Syntax::Token::Escape; end -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#9 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#8 Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#25 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#24 Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#5 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4 Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#7 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#6 Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#21 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#20 Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#14 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#13 Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#23 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#22 Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#26 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#25 Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol) -# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#12 +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#11 Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array) +# alias for symmetry between Token::* and Expression::* +# +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#31 +Regexp::Syntax::Token::EscapeSequence = Regexp::Syntax::Token::Escape + # source://regexp_parser//lib/regexp_parser/syntax/token.rb#11 module Regexp::Syntax::Token::FreeSpace; end @@ -3167,16 +3320,19 @@ Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash) # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#3 module Regexp::Syntax::Token::Meta; end -# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#7 +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8 Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array) +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#5 +Regexp::Syntax::Token::Meta::Alternation = T.let(T.unsafe(nil), Array) + # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#4 Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#5 +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#6 Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8 +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#9 Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol) # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#3 @@ -3197,6 +3353,11 @@ Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#10 Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol) +# alias for symmetry between token symbol and Token module name +# +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#731 +Regexp::Syntax::Token::Property = Regexp::Syntax::Token::UnicodeProperty + # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#3 module Regexp::Syntax::Token::Quantifier; end @@ -3230,6 +3391,11 @@ Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol) # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#28 Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array) +# alias for symmetry between token symbol and Token module name +# +# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#14 +Regexp::Syntax::Token::Set = Regexp::Syntax::Token::CharacterSet + # Type is the same as Backreference so keeping it here, for now. # # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#20 @@ -3286,7 +3452,7 @@ Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#62 Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#708 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#721 Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#13 @@ -3337,19 +3503,22 @@ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Ar # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#129 Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#693 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706 Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#685 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#694 Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#711 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#702 +Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#724 Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol) # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#11 Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#330 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#332 Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#135 @@ -3385,76 +3554,76 @@ Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Arr # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#322 Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#710 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#723 Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#683 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#692 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#332 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#334 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#431 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#433 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#559 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#561 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#594 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#596 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#607 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#609 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#621 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#623 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#631 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#633 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#645 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#647 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#657 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#659 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#668 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#670 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#695 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#708 Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#696 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#709 Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#697 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#710 Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#698 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#711 Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#699 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#712 Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#700 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#713 Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#701 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#714 Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#702 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#715 Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#703 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#716 Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#704 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#717 Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#705 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#718 Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array) -# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706 +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#719 Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array) # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#12 diff --git a/sorbet/rbi/gems/rexml@3.2.5.rbi b/sorbet/rbi/gems/rexml@3.2.5.rbi index 710e900d..a94e5671 100644 --- a/sorbet/rbi/gems/rexml@3.2.5.rbi +++ b/sorbet/rbi/gems/rexml@3.2.5.rbi @@ -946,7 +946,7 @@ end # and in particular, the # {tasks page for documents}[../doc/rexml/tasks/tocs/document_toc_rdoc.html]. # -# source://rexml//lib/rexml/document.rb#39 +# source://rexml//lib/rexml/document.rb#35 class REXML::Document < ::REXML::Element # :call-seq: # new(string = nil, context = {}) -> new_document @@ -3445,7 +3445,7 @@ end # A Source that wraps an IO. See the Source class for method # documentation # -# source://rexml//lib/rexml/source.rb#160 +# source://rexml//lib/rexml/source.rb#159 class REXML::IOSource < ::REXML::Source # block_size has been deprecated # diff --git a/sorbet/rbi/gems/rubocop-ast@1.27.0.rbi b/sorbet/rbi/gems/rubocop-ast@1.29.0.rbi similarity index 95% rename from sorbet/rbi/gems/rubocop-ast@1.27.0.rbi rename to sorbet/rbi/gems/rubocop-ast@1.29.0.rbi index 4262c9be..a0dd3b27 100644 --- a/sorbet/rbi/gems/rubocop-ast@1.27.0.rbi +++ b/sorbet/rbi/gems/rubocop-ast@1.29.0.rbi @@ -22,7 +22,7 @@ end # node when the builder constructs the AST, making its methods available # to all `alias` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#8 class RuboCop::AST::AliasNode < ::RuboCop::AST::Node # Returns the new identifier as specified by the `alias`. # @@ -43,7 +43,7 @@ end # This will be used in place of a plain node when the builder constructs # the AST, making its methods available to all assignment nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/and_asgn_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/and_asgn_node.rb#8 class RuboCop::AST::AndAsgnNode < ::RuboCop::AST::OpAsgnNode # The operator being used for assignment as a symbol. # @@ -84,7 +84,7 @@ end # This will be used in place of a plain node when the builder constructs # the AST, making its methods available to all `arg` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#12 +# source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#9 class RuboCop::AST::ArgNode < ::RuboCop::AST::Node # Checks whether the argument has a default value # @@ -198,7 +198,7 @@ RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash) # This will be used in place of a plain node when the builder constructs # the AST, making its methods available to all assignment nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#8 class RuboCop::AST::AsgnNode < ::RuboCop::AST::Node # The expression being assigned to the variable. # @@ -420,18 +420,18 @@ class RuboCop::AST::Builder < ::Parser::Builders::Default # # @return [Node] the generated node # - # source://rubocop-ast//lib/rubocop/ast/builder.rb#97 + # source://rubocop-ast//lib/rubocop/ast/builder.rb#98 def n(type, children, source_map); end # TODO: Figure out what to do about literal encoding handling... # More details here https://github.com/whitequark/parser/issues/283 # - # source://rubocop-ast//lib/rubocop/ast/builder.rb#103 + # source://rubocop-ast//lib/rubocop/ast/builder.rb#104 def string_value(token); end private - # source://rubocop-ast//lib/rubocop/ast/builder.rb#109 + # source://rubocop-ast//lib/rubocop/ast/builder.rb#110 def node_klass(type); end end @@ -549,7 +549,7 @@ end # This will be used in place of a plain node when the builder constructs # the AST, making its methods available to all assignment nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#8 class RuboCop::AST::CasgnNode < ::RuboCop::AST::Node # The expression being assigned to the variable. # @@ -577,7 +577,7 @@ end # node when the builder constructs the AST, making its methods available # to all `class` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#8 class RuboCop::AST::ClassNode < ::RuboCop::AST::Node # The body of this `class` node. # @@ -607,409 +607,409 @@ end module RuboCop::AST::CollectionNode extend ::Forwardable - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def &(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def *(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def +(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def -(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def <<(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def [](*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def []=(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def all?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def any?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def append(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def assoc(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def at(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def bsearch(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def bsearch_index(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def chain(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def chunk(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def chunk_while(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def clear(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def collect(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def collect!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def collect_concat(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def combination(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def compact(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def compact!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def concat(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def count(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def cycle(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def deconstruct(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def delete(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def delete_at(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def delete_if(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def detect(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def difference(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def dig(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def drop(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def drop_while(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each_cons(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each_entry(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each_index(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each_slice(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each_with_index(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each_with_object(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def empty?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def entries(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def fetch(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def fill(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def filter(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def filter!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def filter_map(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def find(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def find_all(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def find_index(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def first(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def flat_map(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def flatten(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def flatten!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def grep(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def grep_v(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def group_by(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def include?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def index(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def inject(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def insert(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def intersect?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def intersection(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def join(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def keep_if(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def last(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def lazy(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def length(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def map(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def map!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def max(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def max_by(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def member?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def min(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def min_by(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def minmax(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def minmax_by(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def none?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def one?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def pack(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def partition(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def permutation(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def place(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def pop(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def prepend(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def product(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def push(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def rassoc(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def reduce(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def reject(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def reject!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def repeated_combination(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def repeated_permutation(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def replace(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def reverse(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def reverse!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def reverse_each(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def rindex(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def rotate(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def rotate!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def sample(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def select(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def select!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def shelljoin(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def shift(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def shuffle(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def shuffle!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def size(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def slice(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def slice!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def slice_after(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def slice_before(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def slice_when(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def sort(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def sort!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def sort_by(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def sort_by!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def sum(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def take(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def take_while(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def tally(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def to_ary(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def to_h(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def to_set(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def transpose(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def union(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def uniq(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def uniq!(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def unshift(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def values_at(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def zip(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def |(*args, **_arg1, &block); end end @@ -1059,7 +1059,7 @@ end # A node extension for `const` nodes. # -# source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#7 +# source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#6 class RuboCop::AST::ConstNode < ::RuboCop::AST::Node # @return [Boolean] if the constant starts with `::` (aka s(:cbase)) # @@ -1284,7 +1284,7 @@ end # node when the builder constructs the AST, making its methods available # to all `ensure` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/ensure_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/ensure_node.rb#8 class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node # Returns the body of the `ensure` clause. # @@ -1338,7 +1338,7 @@ end # node when the builder constructs the AST, making its methods available # to all `for` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#8 class RuboCop::AST::ForNode < ::RuboCop::AST::Node # Returns the body of the `for` loop. # @@ -1521,7 +1521,7 @@ end # node when the builder constructs the AST, making its methods available # to all `hash` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#14 +# source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#8 class RuboCop::AST::HashNode < ::RuboCop::AST::Node # Checks whether the `hash` literal is delimited by curly braces. # @@ -1753,7 +1753,7 @@ end # node when the builder constructs the AST, making its methods available # to all `in` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#8 class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node # Returns the body of the `in` node. # @@ -1898,9 +1898,9 @@ class RuboCop::AST::IntNode < ::RuboCop::AST::Node include ::RuboCop::AST::NumericNode end -# A node extension for `kwsplat` nodes. This will be used in place of a -# plain node when the builder constructs the AST, making its methods -# available to all `kwsplat` nodes within RuboCop. +# A node extension for `kwsplat` and `forwarded_kwrestarg` nodes. This will be used in +# place of a plain node when the builder constructs the AST, making its methods available to +# all `kwsplat` and `forwarded_kwrestarg` nodes within RuboCop. # # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#8 class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node @@ -1922,6 +1922,13 @@ class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#18 def hash_rocket?; end + # This provides `forwarded_kwrestarg` node to return true to be compatible with `kwsplat` node. + # + # @return [true] + # + # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#48 + def kwsplat_type?; end + # Custom destructuring method. This is used to normalize the branches # for `pair` and `kwsplat` nodes, to add duck typing to `hash` elements. # @@ -2026,10 +2033,10 @@ module RuboCop::AST::MethodDispatchNode # # @return [Boolean] whether the dispatched method is an access modifier # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#53 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#64 def access_modifier?; end - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#262 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#273 def adjacent_def_modifier?(param0 = T.unsafe(nil)); end # Checks whether this node is an arithmetic operation @@ -2037,14 +2044,14 @@ module RuboCop::AST::MethodDispatchNode # @return [Boolean] whether the dispatched method is an arithmetic # operation # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#164 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#175 def arithmetic_operation?; end # Checks whether the dispatched method is a setter method. # # @return [Boolean] whether the dispatched method is a setter # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#96 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#107 def assignment?; end # Checks whether the dispatched method is a bare access modifier that @@ -2053,10 +2060,10 @@ module RuboCop::AST::MethodDispatchNode # @return [Boolean] whether the dispatched method is a bare # access modifier # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#62 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#73 def bare_access_modifier?; end - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#267 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#278 def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end # Checks whether this is a binary operation. @@ -2066,14 +2073,14 @@ module RuboCop::AST::MethodDispatchNode # foo + bar # @return [Boolean] whether this method is a binary operation # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#237 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#248 def binary_operation?; end # Whether this method dispatch has an explicit block. # # @return [Boolean] whether the dispatched method has a block # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#156 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#167 def block_literal?; end # The `block` or `numblock` node associated with this method dispatch, if any. @@ -2081,7 +2088,7 @@ module RuboCop::AST::MethodDispatchNode # @return [BlockNode, nil] the `block` or `numblock` node associated with this method # call or `nil` # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#35 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#46 def block_node; end # Checks whether the name of the dispatched method matches the argument @@ -2090,7 +2097,7 @@ module RuboCop::AST::MethodDispatchNode # @param name [Symbol, String] the method name to check for # @return [Boolean] whether the method name matches the argument # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#89 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#100 def command?(name); end # Checks whether the *explicit* receiver of this method dispatch is a @@ -2099,7 +2106,7 @@ module RuboCop::AST::MethodDispatchNode # @return [Boolean] whether the receiver of this method dispatch # is a `const` node # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#141 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#152 def const_receiver?; end # Checks if this node is part of a chain of `def` or `defs` modifiers. @@ -2111,7 +2118,7 @@ module RuboCop::AST::MethodDispatchNode # private def foo; end # @return [Node | nil] returns the `def|defs` node this is a modifier for, # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#188 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#199 def def_modifier(node = T.unsafe(nil)); end # Checks if this node is part of a chain of `def` or `defs` modifiers. @@ -2123,7 +2130,7 @@ module RuboCop::AST::MethodDispatchNode # private def foo; end # @return [Boolean] whether the `def|defs` node is a modifier or not. # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#176 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#187 def def_modifier?(node = T.unsafe(nil)); end # Checks whether the dispatched method uses a dot to connect the @@ -2134,7 +2141,7 @@ module RuboCop::AST::MethodDispatchNode # # @return [Boolean] whether the method was called with a connecting dot # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#108 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#119 def dot?; end # Checks whether the dispatched method uses a double colon to connect the @@ -2142,7 +2149,7 @@ module RuboCop::AST::MethodDispatchNode # # @return [Boolean] whether the method was called with a connecting dot # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#116 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#127 def double_colon?; end # Checks whether the method dispatch is the implicit form of `#call`, @@ -2150,10 +2157,10 @@ module RuboCop::AST::MethodDispatchNode # # @return [Boolean] whether the method is the implicit form of `#call` # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#149 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#160 def implicit_call?; end - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#246 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#257 def in_macro_scope?(param0 = T.unsafe(nil)); end # Checks whether this is a lambda. Some versions of parser parses @@ -2161,7 +2168,7 @@ module RuboCop::AST::MethodDispatchNode # # @return [Boolean] whether this method is a lambda # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#202 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#213 def lambda?; end # Checks whether this is a lambda literal (stabby lambda.) @@ -2171,7 +2178,7 @@ module RuboCop::AST::MethodDispatchNode # -> (foo) { bar } # @return [Boolean] whether this method is a lambda literal # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#213 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#224 def lambda_literal?; end # Checks whether the dispatched method is a macro method. A macro method @@ -2181,7 +2188,7 @@ module RuboCop::AST::MethodDispatchNode # @note This does not include DSLs that use nested blocks, like RSpec # @return [Boolean] whether the dispatched method is a macro method # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#46 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#57 def macro?; end # The name of the dispatched method as a symbol. @@ -2197,10 +2204,10 @@ module RuboCop::AST::MethodDispatchNode # @return [Boolean] whether the dispatched method is a non-bare # access modifier # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#71 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#82 def non_bare_access_modifier?; end - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#272 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#283 def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end # The receiving node of the method dispatch. @@ -2215,22 +2222,29 @@ module RuboCop::AST::MethodDispatchNode # # @return [Boolean] whether the method was called with a connecting dot # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#124 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#135 def safe_navigation?; end + # The source range for the method name or keyword that dispatches this call. + # + # @return [Parser::Source::Range] the source range for the method name or keyword + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#34 + def selector; end + # Checks whether the *explicit* receiver of this method dispatch is # `self`. # # @return [Boolean] whether the receiver of this method dispatch is `self` # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#132 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#143 def self_receiver?; end # Checks whether the dispatched method is a setter method. # # @return [Boolean] whether the dispatched method is a setter # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#96 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#107 def setter_method?; end # Checks whether the dispatched method is a bare `private` or `protected` @@ -2239,7 +2253,7 @@ module RuboCop::AST::MethodDispatchNode # @return [Boolean] whether the dispatched method is a bare # `private` or `protected` access modifier # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#80 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#91 def special_modifier?; end # Checks whether this is a unary operation. @@ -2249,7 +2263,7 @@ module RuboCop::AST::MethodDispatchNode # -foo # @return [Boolean] whether this method is a unary operation # - # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#224 + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#235 def unary_operation?; end end @@ -2456,7 +2470,7 @@ end # plain node when the builder constructs the AST, making its methods # available to all `module` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#8 class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node # The body of this `module` node. # @@ -3495,7 +3509,7 @@ class RuboCop::AST::NodePattern # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73 def ast; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def captures(*args, **_arg1, &block); end # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#111 @@ -3524,7 +3538,7 @@ class RuboCop::AST::NodePattern # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73 def match_code; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def named_parameters(*args, **_arg1, &block); end # Returns the value of attribute pattern. @@ -3532,7 +3546,7 @@ class RuboCop::AST::NodePattern # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73 def pattern; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def positional_parameters(*args, **_arg1, &block); end # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#95 @@ -3645,7 +3659,7 @@ class RuboCop::AST::NodePattern::Compiler # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#15 def initialize; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def bind(*args, **_arg1, &block); end # Returns the value of attribute binding. @@ -3782,14 +3796,14 @@ end # Variant of the Compiler with tracing information for nodes # -# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#12 +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#10 class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler # @return [Debug] a new instance of Debug # # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#123 def initialize; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def comments(*args, **_arg1, &block); end # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#128 @@ -3803,7 +3817,7 @@ class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern:: # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#132 def parser; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def tokens(*args, **_arg1, &block); end end @@ -4158,6 +4172,9 @@ class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST: private + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#20 + def compile(node); end + # Compilation helpers # # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#165 @@ -4667,9 +4684,9 @@ RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash) # Node class for `$something` # -# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#98 +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#97 class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def arity(*args, **_arg1, &block); end # @return [Boolean] @@ -4683,7 +4700,7 @@ class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::No # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#105 def nb_captures; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def rest?(*args, **_arg1, &block); end end @@ -4797,7 +4814,7 @@ end # Doc on how this fits in the compiling process: # /docs/modules/ROOT/pages/node_pattern.adoc # -# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#13 +# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#12 class RuboCop::AST::NodePattern::Parser < ::Racc::Parser extend ::Forwardable @@ -4918,28 +4935,28 @@ class RuboCop::AST::NodePattern::Parser < ::Racc::Parser # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#463 def _reduce_none(val, _values); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def emit_atom(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def emit_call(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def emit_capture(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def emit_list(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def emit_unary_op(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def emit_union(*args, **_arg1, &block); end # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#40 def inspect; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def next_token(*args, **_arg1, &block); end # (Similar API to `parser` gem) @@ -4983,7 +5000,7 @@ RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), # Overrides Parser to use `WithMeta` variants and provide additional methods # -# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#9 +# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#8 class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser # Returns the value of attribute comments. # @@ -5099,6 +5116,9 @@ RuboCop::AST::NodePattern::Sets::SET_ANY_ALL_NORETURN_ETC = T.let(T.unsafe(nil), # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET_ANY_EMPTY = T.let(T.unsafe(nil), Set) +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ANY_EMPTY_NONE_ETC = T.let(T.unsafe(nil), Set) + # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set) @@ -5216,6 +5236,9 @@ RuboCop::AST::NodePattern::Sets::SET_MODULE_FUNCTION_RUBY2_KEYWORDS = T.let(T.un # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET_NEW_ = T.let(T.unsafe(nil), Set) +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_NEW_COMPILE = T.let(T.unsafe(nil), Set) + # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set) @@ -5256,11 +5279,14 @@ RuboCop::AST::NodePattern::Sets::SET_READ_BINREAD = T.let(T.unsafe(nil), Set) RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set) # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 -RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set) +RuboCop::AST::NodePattern::Sets::SET_REJECT_DELETE_IF_REJECT = T.let(T.unsafe(nil), Set) # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set) +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL = T.let(T.unsafe(nil), Set) + # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set) @@ -5363,6 +5389,9 @@ RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set) # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set) +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET____ETC_4 = T.let(T.unsafe(nil), Set) + # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 RuboCop::AST::NodePattern::Sets::SET_____2 = T.let(T.unsafe(nil), Set) @@ -5391,7 +5420,7 @@ RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp) # This will be used in place of a plain node when the builder constructs # the AST, making its methods available to all assignment nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#9 +# source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#8 class RuboCop::AST::OpAsgnNode < ::RuboCop::AST::Node # @return [AsgnNode] the assignment node # @@ -5424,7 +5453,7 @@ end # This will be used in place of a plain node when the builder constructs # the AST, making its methods available to all assignment nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/or_asgn_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/or_asgn_node.rb#8 class RuboCop::AST::OrAsgnNode < ::RuboCop::AST::OpAsgnNode # The operator being used for assignment as a symbol. # @@ -5692,7 +5721,7 @@ RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String) # This will be used in place of a plain node when the builder constructs # the AST, making its methods available to all `arg` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/procarg0_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/procarg0_node.rb#8 class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode # Returns the name of an argument. # @@ -6029,7 +6058,7 @@ RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash) # plain node when the builder constructs the AST, making its methods # available to all `resbody` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#8 class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node # Returns the body of the `rescue` clause. # @@ -6064,7 +6093,7 @@ end # plain node when the builder constructs the AST, making its methods # available to all `rescue` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#8 class RuboCop::AST::RescueNode < ::RuboCop::AST::Node # Returns the body of the rescue node. # @@ -6136,7 +6165,7 @@ RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Has # plain node when the builder constructs the AST, making its methods # available to all `sclass` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#8 class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node # The body of this `sclass` node. # @@ -6883,7 +6912,7 @@ RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String) # node when the builder constructs the AST, making its methods available # to all `when` nodes within RuboCop. # -# source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#11 +# source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#8 class RuboCop::AST::WhenNode < ::RuboCop::AST::Node # Returns the body of the `when` node. # diff --git a/sorbet/rbi/gems/rubocop-shopify@2.0.1.rbi b/sorbet/rbi/gems/rubocop-shopify@2.14.0.rbi similarity index 100% rename from sorbet/rbi/gems/rubocop-shopify@2.0.1.rbi rename to sorbet/rbi/gems/rubocop-shopify@2.14.0.rbi diff --git a/sorbet/rbi/gems/rubocop-sorbet@0.6.1.rbi b/sorbet/rbi/gems/rubocop-sorbet@0.7.0.rbi similarity index 73% rename from sorbet/rbi/gems/rubocop-sorbet@0.6.1.rbi rename to sorbet/rbi/gems/rubocop-sorbet@0.7.0.rbi index ac943c6c..63d013ee 100644 --- a/sorbet/rbi/gems/rubocop-sorbet@0.6.1.rbi +++ b/sorbet/rbi/gems/rubocop-sorbet@0.7.0.rbi @@ -60,7 +60,7 @@ end # # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#18 class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < ::RuboCop::Cop::Cop - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#110 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#116 def autocorrect(node); end # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#19 @@ -69,33 +69,36 @@ class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < ::RuboCop::Cop::Co # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#51 def dynamic_type_creation_with_block?(param0 = T.unsafe(nil)); end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#66 + def generic_parameter_decl_block_call?(param0 = T.unsafe(nil)); end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#60 - def generic_parameter_decl?(param0 = T.unsafe(nil)); end + def generic_parameter_decl_call?(param0 = T.unsafe(nil)); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#66 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#72 def method_needing_aliasing_on_t?(param0); end # @return [Boolean] # - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#79 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#85 def not_dynamic_type_creation_with_block?(node); end # @return [Boolean] # - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#83 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#89 def not_generic_parameter_decl?(node); end # @return [Boolean] # - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#87 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#93 def not_nil?(node); end # @return [Boolean] # - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#75 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#81 def not_t_let?(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#91 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#97 def on_casgn(node); end # source://rubocop-sorbet//lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb#41 @@ -108,6 +111,48 @@ class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < ::RuboCop::Cop::Co def using_type_alias?(param0 = T.unsafe(nil)); end end +# This cop ensures that callback conditionals are bound to the right type +# so that they are type checked properly. +# +# Auto-correction is unsafe because other libraries define similar style callbacks as Rails, but don't always need +# binding to the attached class. Auto-correcting those usages can lead to false positives and auto-correction +# introduces new typing errors. +# +# @example +# +# # bad +# class Post < ApplicationRecord +# before_create :do_it, if: -> { should_do_it? } +# +# def should_do_it? +# true +# end +# end +# +# # good +# class Post < ApplicationRecord +# before_create :do_it, if: -> { +# T.bind(self, Post) +# should_do_it? +# } +# +# def should_do_it? +# true +# end +# end +# +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/callback_conditionals_binding.rb#35 +class RuboCop::Cop::Sorbet::CallbackConditionalsBinding < ::RuboCop::Cop::Cop + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/callback_conditionals_binding.rb#47 + def autocorrect(node); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/callback_conditionals_binding.rb#99 + def on_send(node); end +end + +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/callback_conditionals_binding.rb#36 +RuboCop::Cop::Sorbet::CallbackConditionalsBinding::CALLBACKS = T.let(T.unsafe(nil), Array) + # This cop disallows the usage of `checked(true)`. This usage could cause # confusion; it could lead some people to believe that a method would be checked # even if runtime checks have not been enabled on the class or globally. @@ -174,9 +219,40 @@ class RuboCop::Cop::Sorbet::ConstantsFromStrings < ::RuboCop::Cop::Cop def on_send(node); end end +# This cop checks for blank lines after signatures. +# +# It also suggests an autocorrect +# +# @example +# +# # bad +# sig { void } +# +# def foo; end +# +# # good +# sig { void } +# def foo; end +# +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb#23 +class RuboCop::Cop::Sorbet::EmptyLineAfterSig < ::RuboCop::Cop::Sorbet::SignatureCop + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb#33 + def autocorrect(node); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb#26 + def on_signature(node); end + + private + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb#48 + def next_method(node); end +end + # This cop checks that the Sorbet sigil comes as the first magic comment in the file. # -# The expected order for magic comments is: typed, (en)?coding, warn_indent then frozen_string_literal. +# The expected order for magic comments is: (en)?coding, typed, warn_indent then frozen_string_literal. # # For example, the following bad ordering: # @@ -190,7 +266,7 @@ end # class Foo; end # ``` # -# Only `typed`, `(en)?coding`, `warn_indent` and `frozen_string_literal` magic comments are considered, +# Only `(en)?coding`, `typed`, `warn_indent` and `frozen_string_literal` magic comments are considered, # other comments or magic comments are left in the same place. # # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb#30 @@ -264,9 +340,6 @@ class RuboCop::Cop::Sorbet::EnforceSignatures < ::RuboCop::Cop::Sorbet::Signatur # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb#55 def autocorrect(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb#51 - def on_block(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb#39 def on_def(node); end @@ -276,6 +349,9 @@ class RuboCop::Cop::Sorbet::EnforceSignatures < ::RuboCop::Cop::Sorbet::Signatur # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb#47 def on_send(node); end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb#51 + def on_signature(node); end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb#74 def scope(node); end @@ -334,6 +410,38 @@ class RuboCop::Cop::Sorbet::EnforceSignatures::SigSuggestion def generate_return; end end +# This cop checks that there is only one Sorbet sigil in a given file +# +# For example, the following class with two sigils +# +# ```ruby +# class Foo; end +# ``` +# +# Will be corrected as: +# +# ```ruby +# class Foo; end +# ``` +# +# Other comments or magic comments are left in place. +# +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb#26 +class RuboCop::Cop::Sorbet::EnforceSingleSigil < ::RuboCop::Cop::Sorbet::ValidSigil + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb#39 + def autocorrect(_node); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb#29 + def investigate(processed_source); end + + protected + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb#55 + def extract_all_sigils(processed_source); end +end + # This cop makes the Sorbet `false` sigil mandatory in all files. # # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/false_sigil.rb#10 @@ -362,27 +470,27 @@ end # def foo; end # end # -# source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb#25 +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb#25 class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims < ::RuboCop::Cop::Cop include ::RuboCop::Cop::RangeHelp - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb#39 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb#39 def autocorrect(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb#35 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb#35 def extend_t_helpers?(param0 = T.unsafe(nil)); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb#31 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb#31 def extend_t_sig?(param0 = T.unsafe(nil)); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb#47 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb#47 def on_send(node); end end -# source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb#28 +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb#28 RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::MSG = T.let(T.unsafe(nil), String) -# source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb#29 +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb#29 RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_include_const_literal.rb#29 @@ -392,6 +500,9 @@ class RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral < ::RuboCop::Cop::Cop # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_include_const_literal.rb#40 def initialize(*_arg0); end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_include_const_literal.rb#56 + def autocorrect(node); end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_include_const_literal.rb#34 def not_lit_const_include?(param0 = T.unsafe(nil)); end @@ -414,6 +525,35 @@ end # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_include_const_literal.rb#30 RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral::MSG = T.let(T.unsafe(nil), String) +# This cop makes sure that RBI files are always located under the defined allowed paths. +# +# Options: +# +# * `AllowedPaths`: A list of the paths where RBI files are allowed (default: ["rbi/**", "sorbet/rbi/**"]) +# +# @example +# # bad +# # lib/some_file.rbi +# # other_file.rbi +# +# # good +# # rbi/external_interface.rbi +# # sorbet/rbi/some_file.rbi +# # sorbet/rbi/any/path/for/file.rbi +# +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb#23 +class RuboCop::Cop::Sorbet::ForbidRBIOutsideOfAllowedPaths < ::RuboCop::Cop::Cop + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb#26 + def investigate(processed_source); end + + private + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb#58 + def allowed_paths; end +end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb#27 class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral < ::RuboCop::Cop::Cop # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb#30 @@ -426,41 +566,84 @@ end # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb#28 RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral::MSG = T.let(T.unsafe(nil), String) +# This cop disallows using `T.unsafe` anywhere. +# +# @example +# +# # bad +# T.unsafe(foo) +# +# # good +# foo +# +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_t_unsafe.rb#17 +class RuboCop::Cop::Sorbet::ForbidTUnsafe < ::RuboCop::Cop::Cop + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_t_unsafe.rb#20 + def on_send(node); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_t_unsafe.rb#18 + def t_unsafe?(param0 = T.unsafe(nil)); end +end + +# This cop disallows using `T.untyped` anywhere. +# +# @example +# +# # bad +# sig { params(my_argument: T.untyped).void } +# def foo(my_argument); end +# +# # good +# sig { params(my_argument: String).void } +# def foo(my_argument); end +# +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_t_untyped.rb#20 +class RuboCop::Cop::Sorbet::ForbidTUntyped < ::RuboCop::Cop::Cop + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_t_untyped.rb#23 + def on_send(node); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_t_untyped.rb#21 + def t_untyped?(param0 = T.unsafe(nil)); end +end + # This cop disallows use of `T.untyped` or `T.nilable(T.untyped)` -# as a prop type for `T::Struct`. +# as a prop type for `T::Struct` or `T::ImmutableStruct`. # # @example # # # bad -# class SomeClass +# class SomeClass < T::Struct # const :foo, T.untyped # prop :bar, T.nilable(T.untyped) # end # # # good -# class SomeClass +# class SomeClass < T::Struct # const :foo, Integer # prop :bar, T.nilable(String) # end # # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#25 class RuboCop::Cop::Sorbet::ForbidUntypedStructProps < ::RuboCop::Cop::Cop - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#48 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#52 def on_class(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#40 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#44 def subclass_of_t_struct?(param0 = T.unsafe(nil)); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#36 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#32 + def t_immutable_struct(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#40 def t_nilable_untyped(param0 = T.unsafe(nil)); end # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#28 def t_struct(param0 = T.unsafe(nil)); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#32 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#36 def t_untyped(param0 = T.unsafe(nil)); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#44 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb#48 def untyped_props(param0); end end @@ -518,6 +701,17 @@ class RuboCop::Cop::Sorbet::KeywordArgumentOrdering < ::RuboCop::Cop::Sorbet::Si def check_order_for_kwoptargs(parameters); end end +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#8 +module RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#15 + def on_assignment(value); end + + class << self + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#9 + def prepended(base); end + end +end + # This cop ensures one ancestor per requires_ancestor line # rather than chaining them as a comma-separated list. # @@ -566,36 +760,41 @@ end # source://rubocop-sorbet//lib/rubocop/cop/sorbet/one_ancestor_per_line.rb#25 RuboCop::Cop::Sorbet::OneAncestorPerLine::MSG = T.let(T.unsafe(nil), String) -# This cop checks for inconsistent ordering of parameters between the -# signature and the method definition. The sorbet-runtime gem raises -# when such inconsistency occurs. +# Forbids the use of redundant `extend T::Sig`. Only for use in +# applications that monkey patch `Module.include(T::Sig)` globally, +# which would make it redundant. # # @example -# # # bad -# sig { params(a: Integer, b: String).void } -# def foo(b:, a:); end +# class Example +# extend T::Sig +# sig { void } +# def no_op; end +# end # # # good -# sig { params(a: Integer, b: String).void } -# def foo(a:, b:); end +# class Example +# sig { void } +# def no_op; end +# end # -# source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/parameters_ordering_in_signature.rb#22 -class RuboCop::Cop::Sorbet::ParametersOrderingInSignature < ::RuboCop::Cop::Sorbet::SignatureCop - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/parameters_ordering_in_signature.rb#27 - def on_signature(node); end +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb#28 +class RuboCop::Cop::Sorbet::RedundantExtendTSig < ::RuboCop::Cop::Cop + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb#42 + def autocorrect(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/parameters_ordering_in_signature.rb#23 - def signature_params(param0); end + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb#32 + def extend_t_sig?(param0 = T.unsafe(nil)); end - private + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb#36 + def on_send(node); end +end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/parameters_ordering_in_signature.rb#53 - def check_for_inconsistent_param_ordering(sig_params_order, parameters); end +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb#29 +RuboCop::Cop::Sorbet::RedundantExtendTSig::MSG = T.let(T.unsafe(nil), String) - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/parameters_ordering_in_signature.rb#41 - def extract_parameters(sig_params); end -end +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb#30 +RuboCop::Cop::Sorbet::RedundantExtendTSig::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_build_order.rb#15 class RuboCop::Cop::Sorbet::SignatureBuildOrder < ::RuboCop::Cop::Sorbet::SignatureCop @@ -641,14 +840,20 @@ RuboCop::Cop::Sorbet::SignatureBuildOrder::ORDER = T.let(T.unsafe(nil), Hash) # # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#11 class RuboCop::Cop::Sorbet::SignatureCop < ::RuboCop::Cop::Cop - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#18 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#30 def on_block(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#22 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#34 def on_signature(_); end # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#14 def signature?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#22 + def with_runtime?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/signatures/signature_cop.rb#26 + def without_runtime?(param0 = T.unsafe(nil)); end end # This cop ensures empty class/module definitions in RBI files are @@ -663,27 +868,27 @@ end # # good # module SomeModule; end # -# source://rubocop-sorbet//lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb#17 +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb#17 class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions < ::RuboCop::Cop::Cop - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb#28 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb#28 def autocorrect(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb#24 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb#24 def on_class(node); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb#20 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb#20 def on_module(node); end protected - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb#34 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb#34 def convert_newlines(source); end - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb#38 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb#38 def process_node(node); end end -# source://rubocop-sorbet//lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb#18 +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb#18 RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions::MSG = T.let(T.unsafe(nil), String) # This cop makes the Sorbet `strict` sigil mandatory in all files. @@ -710,6 +915,28 @@ class RuboCop::Cop::Sorbet::TrueSigil < ::RuboCop::Cop::Sorbet::HasSigil def minimum_strictness; end end +# This cop ensures all constants used as `T.type_alias` are using CamelCase. +# +# @example +# +# # bad +# FOO_OR_BAR = T.type_alias { T.any(Foo, Bar) } +# +# # good +# FooOrBar = T.type_alias { T.any(Foo, Bar) } +# +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/type_alias_name.rb#17 +class RuboCop::Cop::Sorbet::TypeAliasName < ::RuboCop::Cop::Cop + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/type_alias_name.rb#20 + def casgn_type_alias?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/type_alias_name.rb#32 + def on_casgn(node); end +end + +# source://rubocop-sorbet//lib/rubocop/cop/sorbet/type_alias_name.rb#18 +RuboCop::Cop::Sorbet::TypeAliasName::MSG = T.let(T.unsafe(nil), String) + # This cop checks that every Ruby file contains a valid Sorbet sigil. # Adapted from: https://gist.github.com/clarkdave/85aca4e16f33fd52aceb6a0a29936e52 # @@ -755,7 +982,7 @@ class RuboCop::Cop::Sorbet::ValidSigil < ::RuboCop::Cop::Cop # Default is `nil` # - # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/valid_sigil.rb#154 + # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/valid_sigil.rb#155 def minimum_strictness; end # Default is `false` @@ -780,6 +1007,12 @@ RuboCop::Cop::Sorbet::ValidSigil::SIGIL_REGEX = T.let(T.unsafe(nil), Regexp) # source://rubocop-sorbet//lib/rubocop/cop/sorbet/sigils/valid_sigil.rb#51 RuboCop::Cop::Sorbet::ValidSigil::STRICTNESS_LEVELS = T.let(T.unsafe(nil), Array) +module RuboCop::Cop::Style; end + +class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour +end + # source://rubocop-sorbet//lib/rubocop/sorbet/version.rb#3 module RuboCop::Sorbet; end diff --git a/sorbet/rbi/gems/rubocop@1.48.1.rbi b/sorbet/rbi/gems/rubocop@1.54.1.rbi similarity index 95% rename from sorbet/rbi/gems/rubocop@1.48.1.rbi rename to sorbet/rbi/gems/rubocop@1.54.1.rbi index d2c6d445..8b47b384 100644 --- a/sorbet/rbi/gems/rubocop@1.48.1.rbi +++ b/sorbet/rbi/gems/rubocop@1.54.1.rbi @@ -20,6 +20,10 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet end +class Regexp::Expression::Quantifier + include ::RuboCop::Ext::RegexpParser::Expression::Base +end + # source://rubocop//lib/rubocop/version.rb#3 module RuboCop; end @@ -96,7 +100,7 @@ class RuboCop::CLI # source://rubocop//lib/rubocop/cli.rb#152 def act_on_options; end - # source://rubocop//lib/rubocop/cli.rb#186 + # source://rubocop//lib/rubocop/cli.rb#189 def apply_default_formatter; end # source://rubocop//lib/rubocop/cli.rb#121 @@ -104,7 +108,7 @@ class RuboCop::CLI # @raise [Finished] # - # source://rubocop//lib/rubocop/cli.rb#177 + # source://rubocop//lib/rubocop/cli.rb#178 def handle_exiting_options; end # source://rubocop//lib/rubocop/cli.rb#140 @@ -352,6 +356,11 @@ class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base private + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#85 + def bug_tracker_uri; end + # @api private # # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#69 @@ -374,7 +383,7 @@ class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base # @api private # - # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#86 + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#91 def maybe_print_corrected_source; end # @api private @@ -407,6 +416,18 @@ end # source://rubocop//lib/rubocop/cli/command/init_dotfile.rb#9 RuboCop::CLI::Command::InitDotfile::DOTFILE = T.let(T.unsafe(nil), String) +# Start Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/lsp.rb#10 +class RuboCop::CLI::Command::Lsp < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop//lib/rubocop/cli/command/lsp.rb#13 + def run; end +end + # Shows the given cops, or all cops by default, and their configurations # for the current directory. # @@ -501,7 +522,7 @@ end # # @api private # -# source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#12 +# source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#11 class RuboCop::CLI::Command::SuggestExtensions < ::RuboCop::CLI::Command::Base # @api private # @@ -731,7 +752,7 @@ class RuboCop::CommentConfig # source://rubocop//lib/rubocop/comment_config.rb#63 def comment_only_line?(line_number); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def config(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/comment_config.rb#51 @@ -755,7 +776,7 @@ class RuboCop::CommentConfig # source://rubocop//lib/rubocop/comment_config.rb#30 def processed_source; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def registry(*args, **_arg1, &block); end private @@ -931,10 +952,10 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#32 def initialize(hash = T.unsafe(nil), loaded_path = T.unsafe(nil)); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def [](*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def []=(*args, **_arg1, &block); end # @return [Boolean] @@ -971,13 +992,13 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#144 def clusivity_config_for_badge?(badge); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def delete(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/config.rb#110 def deprecation_check; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def dig(*args, **_arg1, &block); end # @return [Boolean] @@ -985,10 +1006,10 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#164 def disabled_new_cops?; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def each_key(*args, **_arg1, &block); end # @return [Boolean] @@ -996,7 +1017,7 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#168 def enabled_new_cops?; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def fetch(*args, **_arg1, &block); end # @return [Boolean] @@ -1035,6 +1056,9 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#155 def for_department(department_name); end + # source://rubocop//lib/rubocop/config.rb#287 + def inspect; end + # True if this is a config file that is shipped with RuboCop # # @return [Boolean] @@ -1042,10 +1066,10 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#78 def internal?; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def key?(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def keys(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/config.rb#49 @@ -1059,10 +1083,10 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#83 def make_excludes_absolute; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def map(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def merge(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/config.rb#230 @@ -1085,7 +1109,7 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#209 def possibly_include_hidden?; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def replace(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/config.rb#73 @@ -1097,22 +1121,22 @@ class RuboCop::Config # source://rubocop//lib/rubocop/config.rb#249 def target_rails_version; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def target_ruby_version(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def to_h(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def to_hash(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/config.rb#69 def to_s; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def transform_values(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def validate(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/config.rb#60 @@ -1120,18 +1144,18 @@ class RuboCop::Config private - # source://rubocop//lib/rubocop/config.rb#318 + # source://rubocop//lib/rubocop/config.rb#322 def department_of(qualified_cop_name); end # @return [Boolean] # - # source://rubocop//lib/rubocop/config.rb#306 + # source://rubocop//lib/rubocop/config.rb#310 def enable_cop?(qualified_cop_name, cop_options); end - # source://rubocop//lib/rubocop/config.rb#293 + # source://rubocop//lib/rubocop/config.rb#297 def read_rails_version_from_bundler_lock_file; end - # source://rubocop//lib/rubocop/config.rb#289 + # source://rubocop//lib/rubocop/config.rb#293 def target_rails_version_from_bundler_lock_file; end class << self @@ -1263,7 +1287,7 @@ class RuboCop::ConfigLoader extend ::RuboCop::FileFinder class << self - # source://rubocop//lib/rubocop/config_loader.rb#130 + # source://rubocop//lib/rubocop/config_loader.rb#138 def add_excludes_from_files(config, config_file); end # Used to add features that were required inside a config or from @@ -1274,10 +1298,10 @@ class RuboCop::ConfigLoader # source://rubocop//lib/rubocop/config_loader.rb#199 def add_loaded_features(loaded_features); end - # source://rubocop//lib/rubocop/config_loader.rb#73 + # source://rubocop//lib/rubocop/config_loader.rb#81 def add_missing_namespaces(path, hash); end - # source://rubocop//lib/rubocop/config_loader.rb#34 + # source://rubocop//lib/rubocop/config_loader.rb#42 def clear_options; end # Returns the path of .rubocop.yml searching upwards in the @@ -1286,115 +1310,115 @@ class RuboCop::ConfigLoader # user's home directory is checked. If there's no .rubocop.yml # there either, the path to the default file is returned. # - # source://rubocop//lib/rubocop/config_loader.rb#97 + # source://rubocop//lib/rubocop/config_loader.rb#105 def configuration_file_for(target_dir); end - # source://rubocop//lib/rubocop/config_loader.rb#101 + # source://rubocop//lib/rubocop/config_loader.rb#109 def configuration_from_file(config_file, check: T.unsafe(nil)); end # Returns the value of attribute debug. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def debug; end # Sets the attribute debug # # @param value the value to set the attribute debug to. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def debug=(_arg0); end # Returns the value of attribute debug. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def debug?; end - # source://rubocop//lib/rubocop/config_loader.rb#140 + # source://rubocop//lib/rubocop/config_loader.rb#148 def default_configuration; end # Sets the attribute default_configuration # # @param value the value to set the attribute default_configuration to. # - # source://rubocop//lib/rubocop/config_loader.rb#28 + # source://rubocop//lib/rubocop/config_loader.rb#36 def default_configuration=(_arg0); end # Returns the value of attribute disable_pending_cops. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def disable_pending_cops; end # Sets the attribute disable_pending_cops # # @param value the value to set the attribute disable_pending_cops to. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def disable_pending_cops=(_arg0); end # Returns the value of attribute enable_pending_cops. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def enable_pending_cops; end # Sets the attribute enable_pending_cops # # @param value the value to set the attribute enable_pending_cops to. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def enable_pending_cops=(_arg0); end # Returns the value of attribute ignore_parent_exclusion. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def ignore_parent_exclusion; end # Sets the attribute ignore_parent_exclusion # # @param value the value to set the attribute ignore_parent_exclusion to. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def ignore_parent_exclusion=(_arg0); end # Returns the value of attribute ignore_parent_exclusion. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def ignore_parent_exclusion?; end # Returns the value of attribute ignore_unrecognized_cops. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def ignore_unrecognized_cops; end # Sets the attribute ignore_unrecognized_cops # # @param value the value to set the attribute ignore_unrecognized_cops to. # - # source://rubocop//lib/rubocop/config_loader.rb#26 + # source://rubocop//lib/rubocop/config_loader.rb#34 def ignore_unrecognized_cops=(_arg0); end # @api private # - # source://rubocop//lib/rubocop/config_loader.rb#148 + # source://rubocop//lib/rubocop/config_loader.rb#156 def inject_defaults!(project_root); end - # source://rubocop//lib/rubocop/config_loader.rb#40 + # source://rubocop//lib/rubocop/config_loader.rb#48 def load_file(file, check: T.unsafe(nil)); end # @raise [TypeError] # - # source://rubocop//lib/rubocop/config_loader.rb#60 + # source://rubocop//lib/rubocop/config_loader.rb#68 def load_yaml_configuration(absolute_path); end # Returns the value of attribute loaded_features. # - # source://rubocop//lib/rubocop/config_loader.rb#29 + # source://rubocop//lib/rubocop/config_loader.rb#37 def loaded_features; end # Return a recursive merge of two hashes. That is, a normal hash merge, # with the addition that any value that is a hash, and occurs in both # arguments, will also be merged. And so on. # - # source://rubocop//lib/rubocop/config_loader.rb#88 + # source://rubocop//lib/rubocop/config_loader.rb#96 def merge(base_hash, derived_hash); end # Merges the given configuration with the default one. @@ -1402,12 +1426,12 @@ class RuboCop::ConfigLoader # source://rubocop//lib/rubocop/config_loader.rb#192 def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end - # source://rubocop//lib/rubocop/config_loader.rb#121 + # source://rubocop//lib/rubocop/config_loader.rb#129 def pending_cops_only_qualified(pending_cops); end # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader.rb#125 + # source://rubocop//lib/rubocop/config_loader.rb#133 def possible_new_cops?(config); end # Returns the path RuboCop inferred as the root of the project. No file @@ -1415,7 +1439,7 @@ class RuboCop::ConfigLoader # # @deprecated Use `RuboCop::ConfigFinder.project_root` instead. # - # source://rubocop//lib/rubocop/config_loader.rb#159 + # source://rubocop//lib/rubocop/config_loader.rb#167 def project_root; end # source://rubocop//lib/rubocop/config_loader.rb#176 @@ -1473,7 +1497,7 @@ class RuboCop::ConfigLoaderResolver # @api private # # source://rubocop//lib/rubocop/config_loader_resolver.rb#45 - def fix_include_paths(base_config_path, hash, key, value); end + def fix_include_paths(base_config_path, hash, path, key, value); end # Return a recursive merge of two hashes. That is, a normal hash merge, # with the addition that any value that is a hash, and occurs in both @@ -1482,7 +1506,7 @@ class RuboCop::ConfigLoaderResolver # # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#98 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#99 def merge(base_hash, derived_hash, **opts); end # Merges the given configuration with the default one. If @@ -1493,7 +1517,7 @@ class RuboCop::ConfigLoaderResolver # # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#74 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#75 def merge_with_default(config, config_file, unset_nil:); end # An `Enabled: true` setting in user configuration for a cop overrides an @@ -1501,7 +1525,7 @@ class RuboCop::ConfigLoaderResolver # # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#118 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#119 def override_department_setting_for_cops(base_hash, derived_hash); end # If a cop was previously explicitly enabled, but then superseded by the @@ -1509,7 +1533,7 @@ class RuboCop::ConfigLoaderResolver # # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#135 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#136 def override_enabled_for_disabled_departments(base_hash, derived_hash); end # @api private @@ -1519,7 +1543,7 @@ class RuboCop::ConfigLoaderResolver # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#54 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#55 def resolve_inheritance_from_gems(hash); end # @api private @@ -1531,79 +1555,79 @@ class RuboCop::ConfigLoaderResolver # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#207 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#208 def base_configs(path, inherit_from, file); end # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#175 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#176 def determine_inherit_mode(hash, key); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#151 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#152 def disabled?(hash, department); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#155 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#156 def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#267 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#268 def gem_config_path(gem_name, relative_config_path); end # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#245 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#246 def handle_disabled_by_default(config, new_default_configuration); end # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#219 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#220 def inherited_file(path, inherit_from, file); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#203 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#204 def merge_hashes?(base_hash, derived_hash, key); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#240 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#241 def remote_file?(uri); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#195 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#196 def should_merge?(mode, key); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#199 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#200 def should_override?(mode, key); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#181 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#182 def should_union?(derived_hash, base_hash, root_mode, key); end # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#263 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#264 def transform(config, &block); end # @api private # - # source://rubocop//lib/rubocop/config_loader_resolver.rb#164 + # source://rubocop//lib/rubocop/config_loader_resolver.rb#165 def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end end @@ -2176,10 +2200,10 @@ class RuboCop::ConfigValidator # source://rubocop//lib/rubocop/config_validator.rb#27 def initialize(config); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def for_all_cops(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def smart_loaded_path(*args, **_arg1, &block); end # source://rubocop//lib/rubocop/config_validator.rb#63 @@ -2503,6 +2527,22 @@ module RuboCop::Cop::AllowedPattern def matches_ignored_pattern?(line); end end +# This module encapsulates the ability to allow certain receivers in a cop. +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#6 +module RuboCop::Cop::AllowedReceivers + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#7 + def allowed_receiver?(receiver); end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#29 + def allowed_receivers; end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#13 + def receiver_name(receiver); end +end + # Error raised when an unqualified cop name is used that could # refer to two or more cops under different departments # @@ -2693,28 +2733,34 @@ module RuboCop::Cop::AutocorrectLogic private # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#46 - def disable_offense(range); end + def disable_offense(offense_range); end - # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#95 + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#111 def disable_offense_at_end_of_line(range, eol_comment); end - # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#99 + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#115 def disable_offense_before_and_after(range_by_lines); end - # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#91 + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#56 + def disable_offense_with_eol_or_surround_comment(range); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#107 def max_line_length; end # Expand the given range to include all of any lines it covers. Does not # include newline at end of the last line. # - # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#81 + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#97 def range_by_lines(range); end - # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#72 + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#88 def range_of_first_line(range); end - # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#61 + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#67 def surrounding_heredoc(offense_range); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#78 + def surrounding_percent_array(offense_range); end end # Identifier of all cops containing a department and cop name. @@ -2903,6 +2949,9 @@ class RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/base.rb#205 def external_dependency_checksum; end + # source://rubocop//lib/rubocop/cop/base.rb#308 + def inspect; end + # Gets called if no message is specified when calling `add_offense` or # `add_global_offense` # Cops are discouraged to override this; instead pass your message directly @@ -2966,83 +3015,83 @@ class RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/base.rb#432 + # source://rubocop//lib/rubocop/cop/base.rb#436 def annotate(message); end - # source://rubocop//lib/rubocop/cop/base.rb#316 + # source://rubocop//lib/rubocop/cop/base.rb#320 def apply_correction(corrector); end # @return [Symbol] offense status # - # source://rubocop//lib/rubocop/cop/base.rb#396 + # source://rubocop//lib/rubocop/cop/base.rb#400 def attempt_correction(range, corrector); end # Reserved for Cop::Cop # - # source://rubocop//lib/rubocop/cop/base.rb#312 + # source://rubocop//lib/rubocop/cop/base.rb#316 def callback_argument(range); end # Called to complete an investigation # - # source://rubocop//lib/rubocop/cop/base.rb#345 + # source://rubocop//lib/rubocop/cop/base.rb#349 def complete_investigation; end # @return [Symbol, Corrector] offense status # - # source://rubocop//lib/rubocop/cop/base.rb#370 + # source://rubocop//lib/rubocop/cop/base.rb#374 def correct(range); end - # source://rubocop//lib/rubocop/cop/base.rb#330 + # source://rubocop//lib/rubocop/cop/base.rb#334 def current_corrector; end # Reserved for Commissioner: # - # source://rubocop//lib/rubocop/cop/base.rb#322 + # source://rubocop//lib/rubocop/cop/base.rb#326 def current_offense_locations; end - # source://rubocop//lib/rubocop/cop/base.rb#334 + # source://rubocop//lib/rubocop/cop/base.rb#338 def current_offenses; end - # source://rubocop//lib/rubocop/cop/base.rb#326 + # source://rubocop//lib/rubocop/cop/base.rb#330 def currently_disabled_lines; end - # source://rubocop//lib/rubocop/cop/base.rb#460 + # source://rubocop//lib/rubocop/cop/base.rb#464 def custom_severity; end - # source://rubocop//lib/rubocop/cop/base.rb#456 + # source://rubocop//lib/rubocop/cop/base.rb#460 def default_severity; end - # source://rubocop//lib/rubocop/cop/base.rb#410 + # source://rubocop//lib/rubocop/cop/base.rb#414 def disable_uncorrectable(range); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/base.rb#446 + # source://rubocop//lib/rubocop/cop/base.rb#450 def enabled_line?(line_number); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/base.rb#438 + # source://rubocop//lib/rubocop/cop/base.rb#442 def file_name_matches_any?(file, parameter, default_result); end - # source://rubocop//lib/rubocop/cop/base.rb#428 + # source://rubocop//lib/rubocop/cop/base.rb#432 def find_message(range, message); end - # source://rubocop//lib/rubocop/cop/base.rb#452 + # source://rubocop//lib/rubocop/cop/base.rb#456 def find_severity(_range, severity); end - # source://rubocop//lib/rubocop/cop/base.rb#473 + # source://rubocop//lib/rubocop/cop/base.rb#477 def range_for_original(range); end - # source://rubocop//lib/rubocop/cop/base.rb#417 + # source://rubocop//lib/rubocop/cop/base.rb#421 def range_from_node_or_range(node_or_range); end - # source://rubocop//lib/rubocop/cop/base.rb#365 + # source://rubocop//lib/rubocop/cop/base.rb#369 def reset_investigation; end # @return [Symbol] offense status # - # source://rubocop//lib/rubocop/cop/base.rb#385 + # source://rubocop//lib/rubocop/cop/base.rb#389 def use_corrector(range, corrector); end class << self @@ -3132,15 +3181,15 @@ class RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/base.rb#356 + # source://rubocop//lib/rubocop/cop/base.rb#360 def builtin?; end - # source://rubocop//lib/rubocop/cop/base.rb#338 + # source://rubocop//lib/rubocop/cop/base.rb#342 def restrict_on_send; end end end -# source://rubocop//lib/rubocop/cop/base.rb#342 +# source://rubocop//lib/rubocop/cop/base.rb#346 RuboCop::Cop::Base::EMPTY_OFFENSES = T.let(T.unsafe(nil), Array) # Reports of an investigation. @@ -4707,7 +4756,7 @@ class RuboCop::Cop::Cop < ::RuboCop::Cop::Base def correction_lambda; end # source://rubocop//lib/rubocop/cop/cop.rb#144 - def dedup_on_node(node); end + def dedupe_on_node(node); end # Just for legacy # @@ -4845,7 +4894,7 @@ class RuboCop::Cop::Corrector < ::Parser::Source::TreeRewriter # Legacy # - # source://parser/3.2.1.1/lib/parser/source/tree_rewriter.rb#252 + # source://parser/3.2.2.3/lib/parser/source/tree_rewriter.rb#252 def rewrite; end # Swaps sources at the given ranges. @@ -5512,7 +5561,7 @@ RuboCop::Cop::Gemspec::DependencyVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil) # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#59 RuboCop::Cop::Gemspec::DependencyVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp) -# Checks that deprecated attribute attributes are not set in a gemspec file. +# Checks that deprecated attributes are not set in a gemspec file. # Removing deprecated attributes allows the user to receive smaller packed gems. # # @example @@ -6738,7 +6787,7 @@ module RuboCop::Cop::Heredoc # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#28 def delimiter_string(node); end - # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#32 + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#34 def heredoc_type(node); end # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#23 @@ -7758,7 +7807,7 @@ RuboCop::Cop::Layout::CaseIndentation::MSG = T.let(T.unsafe(nil), String) # end # end # -# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#135 +# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#142 class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base include ::RuboCop::Cop::VisibilityHelp include ::RuboCop::Cop::CommentsHelp @@ -7767,29 +7816,35 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # Validates code style on class declaration. # Add offense when find a node out of expected order. # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#151 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#158 def on_class(class_node); end + # Validates code style on class declaration. + # Add offense when find a node out of expected order. + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#158 + def on_sclass(class_node); end + private # Autocorrect by swapping between two nodes autocorrecting them # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#166 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#174 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#297 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#305 def begin_pos_with_comment(node); end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#320 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#328 def buffer; end # Setting categories hash allow you to group methods in group to match # in the {expected_order}. # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#332 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#340 def categories; end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#226 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#234 def class_elements(class_node); end # Classifies a node to match with something in the {expected_order} @@ -7801,21 +7856,21 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # by method name # @return String otherwise trying to {humanize_node} of the current node # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#186 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#194 def classify(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#263 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#271 def dynamic_constant?(node); end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#287 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#295 def end_position_for(node); end # Load expected order from `ExpectedOrder` config. # Define new terms in the expected order by adding new {categories}. # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#326 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#334 def expected_order; end # Categorize a node according to the {expected_order} @@ -7825,51 +7880,51 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # @param node to be analysed. # @return [String] with the key category or the `method_name` as string # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#204 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#212 def find_category(node); end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#316 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#324 def find_heredoc(node); end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#254 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#262 def humanize_node(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#238 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#246 def ignore?(node, classification); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#245 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#253 def ignore_for_autocorrect?(node, sibling); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#281 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#289 def marked_as_private_constant?(node, name); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#271 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#279 def private_constant?(node); end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#312 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#320 def start_line_position(node); end - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#217 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#225 def walk_over_nested_class_definition(class_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#308 + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#316 def whole_line_comment_at_line?(line); end end -# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#140 +# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#147 RuboCop::Cop::Layout::ClassStructure::HUMANIZED_NODE_TYPE = T.let(T.unsafe(nil), Hash) -# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#147 +# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#154 RuboCop::Cop::Layout::ClassStructure::MSG = T.let(T.unsafe(nil), String) # Checks the indentation of here document closings. @@ -7914,53 +7969,53 @@ RuboCop::Cop::Layout::ClassStructure::MSG = T.let(T.unsafe(nil), String) # Hi # EOS # -# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#49 +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#48 class RuboCop::Cop::Layout::ClosingHeredocIndentation < ::RuboCop::Cop::Base include ::RuboCop::Cop::Heredoc extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#58 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#57 def on_heredoc(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#75 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#74 def argument_indentation_correct?(node); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#83 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#82 def closing_indentation(node); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#102 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#101 def find_node_used_heredoc_argument(node); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#91 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#90 def heredoc_closing(node); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#87 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#86 def heredoc_opening(node); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#118 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#117 def indent_level(source_line); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#95 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#94 def indented_end(node); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#110 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#109 def message(node); end - # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#71 + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#70 def opening_indentation(node); end end -# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#54 +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#53 RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#55 +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#54 RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG_ARG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#53 +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#52 RuboCop::Cop::Layout::ClosingHeredocIndentation::SIMPLE_HEREDOC = T.let(T.unsafe(nil), String) # Checks the indentation of hanging closing parentheses in @@ -8925,7 +8980,7 @@ class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#144 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#145 def autocorrect(corrector, prev_def, node, count); end # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#130 @@ -8944,73 +8999,84 @@ class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#267 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#290 def allowance_range?; end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#251 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#274 def autocorrect_insert_lines(corrector, newline_pos, count); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#244 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#267 def autocorrect_remove_lines(corrector, newline_pos, count); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#208 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#227 def blank_lines_count_between(first_def_node, second_def_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#162 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#171 def candidate?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#172 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#191 def class_candidate?(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#232 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#255 def def_end(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#228 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#163 + def def_location(correction_node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#247 def def_start(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#236 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#178 + def empty_line_between_macros; end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#259 def end_loc(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#186 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#205 def expected_lines; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#204 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#223 def line_count_allowed?(count); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#220 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#239 def lines_between_defs(first_def_node, second_def_node); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#216 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#182 + def macro_candidate?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#235 def maximum_empty_lines; end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#180 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#199 def message(node, count: T.unsafe(nil)); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#168 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#187 def method_candidate?(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#212 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#231 def minimum_empty_lines; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#176 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#195 def module_candidate?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#195 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#214 def multiple_blank_lines_groups?(first_def_node, second_def_node); end - # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#258 + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#281 def node_type(node); end class << self @@ -9111,85 +9177,85 @@ class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Bas # @return [EmptyLinesAroundAccessModifier] a new instance of EmptyLinesAroundAccessModifier # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#54 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#56 def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#79 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#81 def on_block(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#60 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#62 def on_class(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#69 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#71 def on_module(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#79 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#81 def on_numblock(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#74 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#76 def on_sclass(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#85 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#87 def on_send(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#113 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#115 def allowed_only_before_style?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#162 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#164 def block_start?(line); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#168 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#170 def body_end?(line); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#156 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#158 def class_def?(line); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#122 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#124 def correct_next_line_if_denied_style(corrector, node, line); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#152 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#154 def empty_lines_around?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#102 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#104 def expected_empty_lines?(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#178 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#180 def message(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#187 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#189 def message_for_around_style(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#197 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#199 def message_for_only_before_style(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#174 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#176 def next_empty_line_range(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#146 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#148 def next_line_empty?(last_send_line); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#139 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#141 def previous_line_empty?(send_line); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#135 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#137 def previous_line_ignoring_comments(processed_source, send_line); end end @@ -9205,6 +9271,9 @@ RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_AND_AFTER = T.l # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#51 RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String) +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#54 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Checks if empty lines exist around the arguments # of a method invocation. # @@ -9681,36 +9750,42 @@ class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < ::RuboCo include ::RuboCop::Cop::Layout::EmptyLinesAroundBody extend ::RuboCop::Cop::AutoCorrector + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 + def on_block(node); end + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 def on_def(node); end # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 def on_defs(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#72 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#74 def on_kwbegin(node); end + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 + def on_numblock(node); end + private - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#79 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#81 def check_body(body, line_of_def_or_kwbegin); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#106 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#108 def keyword_locations(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#123 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#125 def keyword_locations_in_ensure(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#119 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#121 def keyword_locations_in_rescue(node); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#94 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#96 def last_rescue_and_end_on_same_line(body); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#98 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#100 def message(location, keyword); end - # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#102 + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#104 def style; end end @@ -9889,6 +9964,9 @@ class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#105 def on_case(node); end + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#105 + def on_case_match(node); end + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#81 def on_class(node); end @@ -9909,28 +9987,28 @@ class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#160 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#161 def alignment_node(node); end - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#171 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#172 def alignment_node_for_variable_style(node); end - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#141 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#142 def asgn_variable_align_with(outer_node, inner_node); end - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#186 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#190 def assignment_or_operator_method(node); end - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#115 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#116 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#130 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#131 def check_asgn_alignment(outer_node, inner_node); end - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#119 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#120 def check_assignment(node, rhs); end - # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#151 + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#152 def check_other_alignment(node); end end @@ -10033,13 +10111,13 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#171 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#176 def align_column(asgn_token); end - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#148 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#153 def align_equal_sign(corrector, token, align_to); end - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#138 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#143 def align_equal_signs(range, corrector); end # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#52 @@ -10047,46 +10125,46 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#104 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#109 def aligned_tok?(token); end - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#160 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#165 def all_relevant_assignment_lines(line_number); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#180 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#185 def allow_for_trailing_comments?; end - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#73 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#78 def check_assignment(token); end - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#82 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#87 def check_other(token1, token2, ast); end - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#63 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#68 def check_tokens(ast, token1, token2); end # @yield [range_between(start_pos, end_pos)] # - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#92 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#97 def extra_space_range(token1, token2); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#134 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#139 def force_equal_sign_alignment?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#112 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#117 def ignored_range?(ast, start_pos); end # Returns an array of ranges that should not be reported. It's the # extra spaces between the keys and values in a multiline hash, # since those are handled by the Layout/HashAlignment cop. # - # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#119 + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#124 def ignored_ranges(ast); end end @@ -10240,7 +10318,7 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#217 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#222 def eligible_method_call?(param0 = T.unsafe(nil)); end # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#155 @@ -10254,58 +10332,63 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#276 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#281 def argument_alignment_config; end - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#169 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#174 def autocorrect(corrector, node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#173 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#178 def bare_operator?(node); end - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#193 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#198 def base_indentation(node); end - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#221 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#226 def base_range(send_node, arg_node); end # Returns the column of the given range. For single line ranges, this # is simple. For ranges with line breaks, we look a the last code line. # - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#233 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#238 def column_of(range); end - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#254 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#259 def comment_lines; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#272 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#277 def enable_layout_first_method_argument_line_break?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#266 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#271 def enforce_first_argument_with_fixed_indentation?; end - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#177 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#182 def message(arg_node); end - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#262 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#267 def on_new_investigation; end # Takes the line number of a given code line and returns a string # containing the previous line that's not a comment line or a blank # line. # - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#245 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#250 def previous_code_line(line_number); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#201 + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#170 + def should_check?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#206 def special_inner_call_indentation?(node); end end @@ -10435,71 +10518,60 @@ RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), S # Checks for a line break before the first element in a # multi-line array. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # [ :a, # :b] # -# # bad -# [ :a, { -# :b => :c -# }] -# -# # good -# [:a, :b] -# # # good # [ # :a, # :b] # # # good -# [ -# :a, { -# :b => :c -# }] -# @example AllowMultilineFinalElement: true +# [:a, :b] +# @example AllowMultilineFinalElement: false (default) # # # bad -# [ :a, -# :b] -# -# # good # [ :a, { # :b => :c # }] # # # good # [ -# :a, -# :b] +# :a, { +# :b => :c +# }] +# @example AllowMultilineFinalElement: true # # # good -# [:a, :b] +# [:a, { +# :b => :c +# }] # -# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#52 +# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#43 class RuboCop::Cop::Layout::FirstArrayElementLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::FirstElementLineBreak extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#58 + # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#49 def on_array(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#66 + # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#57 def assignment_on_same_line?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#71 + # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#62 def ignore_last_element?; end end -# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#56 +# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#47 RuboCop::Cop::Layout::FirstArrayElementLineBreak::MSG = T.let(T.unsafe(nil), String) # Checks the indentation of the first key in a hash literal @@ -10671,17 +10743,12 @@ RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), St # Checks for a line break before the first element in a # multi-line hash. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # { a: 1, # b: 2} # -# # bad -# { a: 1, b: { -# c: 3 -# }} -# # # good # { # a: 1, @@ -10692,11 +10759,13 @@ RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), St # a: 1, b: { # c: 3 # }} -# @example AllowMultilineFinalElement: true +# @example AllowMultilineFinalElement: false (default) # # # bad -# { a: 1, -# b: 2} +# { a: 1, b: { +# c: 3 +# }} +# @example AllowMultilineFinalElement: true # # # bad # { a: 1, @@ -10709,45 +10778,44 @@ RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), St # c: 3 # }} # -# # good -# { -# a: 1, -# b: 2 } -# -# # good -# { -# a: 1, b: { -# c: 3 -# }} -# -# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#58 +# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#46 class RuboCop::Cop::Layout::FirstHashElementLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::FirstElementLineBreak extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#64 + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#52 def on_hash(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#74 + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#62 def ignore_last_element?; end end -# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#62 +# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#50 RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), String) # Checks for a line break before the first argument in a # multi-line method call. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # method(foo, bar, # baz) # +# # good +# method( +# foo, bar, +# baz) +# +# # ignored +# method foo, bar, +# baz +# @example AllowMultilineFinalElement: false (default) +# # # bad # method(foo, bar, { # baz: "a", @@ -10756,26 +10824,13 @@ RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), Stri # # # good # method( -# foo, bar, -# baz) -# -# # good -# method( # foo, bar, { # baz: "a", # qux: "b", # }) -# -# # ignored -# method foo, bar, -# baz # @example AllowMultilineFinalElement: true # # # bad -# method(foo, bar, -# baz) -# -# # bad # method(foo, # bar, # { @@ -10792,11 +10847,6 @@ RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), Stri # # # good # method( -# foo, bar, -# baz) -# -# # good -# method( # foo, # bar, # { @@ -10805,39 +10855,35 @@ RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), Stri # } # ) # -# # ignored -# method foo, bar, -# baz -# -# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#76 +# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#66 class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::FirstElementLineBreak extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#82 + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#72 def on_csend(node); end - # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#82 + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#72 def on_send(node); end - # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#82 + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#72 def on_super(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#101 + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#91 def ignore_last_element?; end end -# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#80 +# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#70 RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), String) # Checks for a line break before the first parameter in a # multi-line method parameter definition. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # def method(foo, bar, @@ -10845,13 +10891,6 @@ RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), S # do_something # end # -# # bad -# def method(foo, bar, baz = { -# :a => "b", -# }) -# do_something -# end -# # # good # def method( # foo, bar, @@ -10859,28 +10898,14 @@ RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), S # do_something # end # -# # good -# def method( -# foo, bar, baz = { -# :a => "b", -# }) -# do_something -# end -# # # ignored # def method foo, # bar # do_something # end -# @example AllowMultilineFinalElement: true +# @example AllowMultilineFinalElement: false (default) # # # bad -# def method(foo, bar, -# baz) -# do_something -# end -# -# # good # def method(foo, bar, baz = { # :a => "b", # }) @@ -10889,37 +10914,40 @@ RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), S # # # good # def method( -# foo, bar, -# baz) +# foo, bar, baz = { +# :a => "b", +# }) # do_something # end +# @example AllowMultilineFinalElement: true # -# # ignored -# def method foo, -# bar +# # good +# def method(foo, bar, baz = { +# :a => "b", +# }) # do_something # end # -# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#73 +# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#56 class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::FirstElementLineBreak extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#79 + # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#62 def on_def(node); end - # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#79 + # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#62 def on_defs(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#86 + # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#69 def ignore_last_element?; end end -# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#77 +# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#60 RuboCop::Cop::Layout::FirstMethodParameterLineBreak::MSG = T.let(T.unsafe(nil), String) # Checks the indentation of the first parameter in a method @@ -11377,7 +11405,7 @@ class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop:: # @return [Boolean] # # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#162 - def end_keyword_before_closing_parentesis?(parenthesized_send_node); end + def end_keyword_before_closing_parenthesis?(parenthesized_send_node); end # @return [Boolean] # @@ -12417,7 +12445,7 @@ class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < ::RuboCop::C include ::RuboCop::Cop::Alignment extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#95 + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#97 def autocorrect(corrector, node); end # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#83 @@ -12425,26 +12453,26 @@ class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < ::RuboCop::C private - # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#135 + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#137 def add_offense_and_correction(node, message); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#107 + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#109 def always_indented?(dstr_node); end - # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#126 + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#128 def base_column(child); end - # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#111 + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#113 def check_aligned(children, start_index); end - # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#120 + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#122 def check_indented(children); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#101 + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#103 def strings_concatenated_with_backslash?(dstr_node); end end @@ -12752,7 +12780,7 @@ RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.uns # Ensures that each item in a multi-line array # starts on a separate line. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # [ @@ -12760,11 +12788,6 @@ RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.uns # c # ] # -# # bad -# [ a, b, foo( -# bar -# )] -# # # good # [ # a, @@ -12780,52 +12803,36 @@ RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.uns # bar # ) # ] -# @example AllowMultilineFinalElement: true +# @example AllowMultilineFinalElement: false (default) # # # bad -# [ -# a, b, -# c -# ] -# -# # good -# [ a, b, foo( +# [a, b, foo( # bar # )] +# @example AllowMultilineFinalElement: true # # # good -# [ -# a, -# b, -# c -# ] -# -# # good -# [ -# a, -# b, -# foo( +# [a, b, foo( # bar -# ) -# ] +# )] # -# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#66 +# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#47 class RuboCop::Cop::Layout::MultilineArrayLineBreaks < ::RuboCop::Cop::Base include ::RuboCop::Cop::MultilineElementLineBreaks extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#72 + # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#53 def on_array(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#78 + # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#59 def ignore_last_element?; end end -# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#70 +# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#51 RuboCop::Cop::Layout::MultilineArrayLineBreaks::MSG = T.let(T.unsafe(nil), String) # Checks whether the multiline assignments have a newline @@ -13124,7 +13131,7 @@ RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsa # Ensures that each key in a multi-line hash # starts on a separate line. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # { @@ -13132,11 +13139,6 @@ RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsa # c: 3 # } # -# # bad -# { a: 1, b: { -# c: 3, -# }} -# # # good # { # a: 1, @@ -13151,56 +13153,41 @@ RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsa # c: 3, # } # } -# @example AllowMultilineFinalElement: true +# @example AllowMultilineFinalElement: false (default) # # # bad -# { -# a: 1, b: 2, -# c: 3 -# } -# -# # good # { a: 1, b: { # c: 3, # }} +# @example AllowMultilineFinalElement: true # # # good -# { -# a: 1, -# b: 2, -# c: 3 -# } -# -# # good -# { -# a: 1, -# b: { +# { a: 1, b: { # c: 3, -# } -# } +# }} # -# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#65 +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#46 class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < ::RuboCop::Cop::Base include ::RuboCop::Cop::MultilineElementLineBreaks extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#71 + # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#52 def on_hash(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#87 + # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#68 def ignore_last_element?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#83 + # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#64 def starts_with_curly_brace?(node); end end -# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#69 +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#50 RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), String) # Ensures that each argument in a multi-line method call @@ -13209,7 +13196,7 @@ RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), Str # NOTE: This cop does not move the first argument, if you want that to # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # foo(a, b, @@ -13230,6 +13217,7 @@ RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), Str # # # good # foo(a, b, c) +# @example AllowMultilineFinalElement: false (default) # # # good # foo( @@ -13241,26 +13229,6 @@ RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), Str # ) # @example AllowMultilineFinalElement: true # -# # bad -# foo(a, b, -# c -# ) -# -# # good -# foo(a, b, { -# foo: "bar", -# }) -# -# # good -# foo( -# a, -# b, -# c -# ) -# -# # good -# foo(a, b, c) -# # # good # foo( # a, @@ -13270,23 +13238,23 @@ RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), Str # } # ) # -# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#73 +# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#56 class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks < ::RuboCop::Cop::Base include ::RuboCop::Cop::MultilineElementLineBreaks extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#79 + # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#62 def on_send(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#98 + # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#81 def ignore_last_element?; end end -# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#77 +# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#60 RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::MSG = T.let(T.unsafe(nil), String) # Checks that the closing brace in a method call is either @@ -13674,7 +13642,7 @@ RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = # NOTE: This cop does not move the first argument, if you want that to # be on a separate line, see `Layout/FirstMethodParameterLineBreak`. # -# @example AllowMultilineFinalElement: false (default) +# @example # # # bad # def foo(a, b, @@ -13682,12 +13650,6 @@ RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = # ) # end # -# # bad -# def foo(a, b = { -# foo: "bar", -# }) -# end -# # # good # def foo( # a, @@ -13708,58 +13670,38 @@ RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = # # good # def foo(a, b, c) # end -# @example AllowMultilineFinalElement: true +# @example AllowMultilineFinalElement: false (default) # # # bad -# def foo(a, b, -# c -# ) -# end -# -# # good # def foo(a, b = { # foo: "bar", # }) # end +# @example AllowMultilineFinalElement: true # # # good -# def foo( -# a, -# b, -# c -# ) -# end -# -# # good -# def foo( -# a, -# b = { +# def foo(a, b = { # foo: "bar", -# } -# ) -# end -# -# # good -# def foo(a, b, c) +# }) # end # -# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#81 +# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#57 class RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks < ::RuboCop::Cop::Base include ::RuboCop::Cop::MultilineElementLineBreaks extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#87 + # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#63 def on_def(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#95 + # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#71 def ignore_last_element?; end end -# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#85 +# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#61 RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks::MSG = T.let(T.unsafe(nil), String) # Checks the indentation of the right hand side operand in binary operations that @@ -13998,20 +13940,20 @@ class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#113 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#112 def comment_within?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#83 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#82 def configured_to_not_be_inspected?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#107 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#106 def convertible_block?(node); end - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#133 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#132 def max_line_length; end # @return [Boolean] @@ -14021,7 +13963,7 @@ class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#90 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#89 def other_cop_takes_precedence?(node); end # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#70 @@ -14029,20 +13971,20 @@ class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#96 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#95 def single_line_block_chain_enabled?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#100 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#99 def suitable_as_single_line?(node); end - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#124 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#123 def to_single_line(source); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#119 + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#118 def too_long?(node); end end @@ -14254,6 +14196,13 @@ class RuboCop::Cop::Layout::SpaceAfterComma < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#21 def space_style_before_rcurly; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#32 + def before_semicolon?(token); end end # Checks for space between a method name and a left parenthesis in defs. @@ -14864,49 +14813,49 @@ class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#236 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#238 def align_hash_cop_config; end - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#179 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#181 def autocorrect(corrector, range); end - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#163 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#165 def check_operator(type, operator, right_operand); end - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#189 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#191 def enclose_operator_with_space(corrector, range); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#216 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#218 def excess_leading_space?(type, operator, with_space); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#231 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#233 def excess_trailing_space?(right_operand, with_space); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#248 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#250 def force_equal_sign_alignment?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#240 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#242 def hash_table_style?; end # @yield [msg] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#174 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#176 def offense(type, operator, with_space, right_operand); end - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#202 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#204 def offense_message(type, operator, with_space, right_operand); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#159 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#161 def operator_with_regular_syntax?(send_node); end # @return [Boolean] @@ -14916,12 +14865,12 @@ class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#252 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#254 def should_not_have_surrounding_space?(operator); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#244 + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#246 def space_around_exponent_operator?; end class << self @@ -15154,7 +15103,7 @@ class RuboCop::Cop::Layout::SpaceBeforeFirstArg < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#54 + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#55 def expect_params_after_method_name?(node); end # @return [Boolean] @@ -15164,7 +15113,7 @@ class RuboCop::Cop::Layout::SpaceBeforeFirstArg < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#50 + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#51 def regular_method_call_with_arguments?(node); end class << self @@ -15557,7 +15506,7 @@ class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#205 def space_inside_right_brace(inner, right_brace, column); end - # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#251 + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#253 def style_for_empty_braces; end end @@ -15748,12 +15697,12 @@ class RuboCop::Cop::Layout::SpaceInsideParens < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#161 def can_be_ignored?(token1, token2); end - # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#115 - def correct_extaneus_space_between_consecutive_parens(token1, token2); end - # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#99 def correct_extraneous_space(tokens); end + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#115 + def correct_extraneous_space_between_consecutive_parens(token1, token2); end + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#124 def correct_extraneous_space_in_empty_parens(token1, token2); end @@ -16407,30 +16356,34 @@ RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsaf class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#62 + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#64 def on_csend(node); end - # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#62 + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#64 def on_send(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#81 + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#85 def allowed_method_pattern?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#77 + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#81 def ambiguous_block_association?(send_node); end - # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#87 + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#91 def message(send_node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#97 + def wrap_in_parentheses(corrector, node); end end -# source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#58 +# source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#60 RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG = T.let(T.unsafe(nil), String) # Checks for ambiguous operators in the first argument of a @@ -17207,18 +17160,23 @@ class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/lint/debugger.rb#98 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#95 + def assumed_usage_context?(node); end + + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#102 def chained_method_name(send_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/debugger.rb#92 + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#89 def debugger_method?(send_node); end - # source://rubocop//lib/rubocop/cop/lint/debugger.rb#85 + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#82 def debugger_methods; end - # source://rubocop//lib/rubocop/cop/lint/debugger.rb#81 + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#78 def message(node); end end @@ -17289,7 +17247,7 @@ RuboCop::Cop::Lint::DeprecatedClassMethods::DIR_ENV_FILE_CONSTANTS = T.let(T.uns RuboCop::Cop::Lint::DeprecatedClassMethods::MSG = T.let(T.unsafe(nil), String) # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#41 -RuboCop::Cop::Lint::DeprecatedClassMethods::PREFERRED_METHDOS = T.let(T.unsafe(nil), Hash) +RuboCop::Cop::Lint::DeprecatedClassMethods::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash) # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#37 RuboCop::Cop::Lint::DeprecatedClassMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) @@ -17680,6 +17638,7 @@ end RuboCop::Cop::Lint::DuplicateElsifCondition::MSG = T.let(T.unsafe(nil), String) # Checks for duplicated keys in hash literals. +# This cop considers both primitive types and constants for the hash keys. # # This cop mirrors a warning in Ruby 2.2. # @@ -17694,15 +17653,15 @@ RuboCop::Cop::Lint::DuplicateElsifCondition::MSG = T.let(T.unsafe(nil), String) # # hash = { food: 'apple', other_food: 'orange' } # -# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#21 +# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#22 class RuboCop::Cop::Lint::DuplicateHashKey < ::RuboCop::Cop::Base include ::RuboCop::Cop::Duplication - # source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#26 + # source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#27 def on_hash(node); end end -# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#24 +# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#25 RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String) # Checks for duplicated magic comments. @@ -17748,6 +17707,106 @@ end # source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#33 RuboCop::Cop::Lint::DuplicateMagicComment::MSG = T.let(T.unsafe(nil), String) +# Checks that there are no repeated patterns used in `in` keywords. +# +# @example +# +# # bad +# case x +# in 'first' +# do_something +# in 'first' +# do_something_else +# end +# +# # good +# case x +# in 'first' +# do_something +# in 'second' +# do_something_else +# end +# +# # bad - repeated alternate patterns with the same conditions don't depend on the order +# case x +# in foo | bar +# first_method +# in bar | foo +# second_method +# end +# +# # good +# case x +# in foo | bar +# first_method +# in bar | baz +# second_method +# end +# +# # bad - repeated hash patterns with the same conditions don't depend on the order +# case x +# in foo: a, bar: b +# first_method +# in bar: b, foo: a +# second_method +# end +# +# # good +# case x +# in foo: a, bar: b +# first_method +# in bar: b, baz: c +# second_method +# end +# +# # bad - repeated array patterns with elements in the same order +# case x +# in [foo, bar] +# first_method +# in [foo, bar] +# second_method +# end +# +# # good +# case x +# in [foo, bar] +# first_method +# in [bar, foo] +# second_method +# end +# +# # bad - repeated the same patterns and guard conditions +# case x +# in foo if bar +# first_method +# in foo if bar +# second_method +# end +# +# # good +# case x +# in foo if bar +# first_method +# in foo if baz +# second_method +# end +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#90 +class RuboCop::Cop::Lint::DuplicateMatchPattern < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#97 + def on_case_match(case_node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#108 + def pattern_identity(pattern); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#93 +RuboCop::Cop::Lint::DuplicateMatchPattern::MSG = T.let(T.unsafe(nil), String) + # Checks for duplicated instance (or singleton) method # definitions. # @@ -17897,26 +17956,40 @@ class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement < ::RuboCop::Cop: include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#36 + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#37 def each_repeated_character_class_element_loc(node); end - # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#27 + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#29 def on_regexp(node); end private - # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#83 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#102 + def escaped_octal?(string); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#54 + def group_expressions(node, expressions); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#110 def interpolation_locs(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#65 - def skip_expression?(expr); end + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#106 + def octal?(char); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#71 + def pop_octal_digits(current_child, expressions); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#78 - def start_with_escaped_zero_number?(current_child, next_child); end + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#89 + def skip_expression?(expr); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#80 + def source_range(children); end # Since we blank interpolations with a space for every char of the interpolation, we would # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes @@ -17924,13 +17997,16 @@ class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement < ::RuboCop::Cop: # # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#72 + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#96 def within_interpolation?(node, child); end end # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#25 RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::MSG_REPEATED_ELEMENT = T.let(T.unsafe(nil), String) +# source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#27 +RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::OCTAL_DIGITS_AFTER_ESCAPE = T.let(T.unsafe(nil), Integer) + # Checks for duplicate ``require``s and ``require_relative``s. # # @example @@ -18676,13 +18752,13 @@ end # source://rubocop//lib/rubocop/cop/lint/ensure_return.rb#51 RuboCop::Cop::Lint::EnsureReturn::MSG = T.let(T.unsafe(nil), String) -# This cop emulates the following Ruby warnings in Ruby 2.6. +# Emulates the following Ruby warnings in Ruby 2.6. # # [source,console] # ---- -# % cat example.rb +# $ cat example.rb # ERB.new('hi', nil, '-', '@output_buffer') -# % ruby -rerb example.rb +# $ ruby -rerb example.rb # example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is # deprecated. Do not use it, and specify other arguments as keyword arguments. # example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is @@ -18731,42 +18807,42 @@ RuboCop::Cop::Lint::EnsureReturn::MSG = T.let(T.unsafe(nil), String) # ERB.new(str, nil, '-', '@output_buffer') # end # -# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#62 +# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#61 class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector extend ::RuboCop::Cop::TargetRubyVersion - # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#84 + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#83 def erb_new_with_non_keyword_arguments(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#89 + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#88 def on_send(node); end private - # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#154 + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#153 def arguments_range(node); end - # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#109 + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#108 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#124 + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#123 def build_kwargs(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#120 + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#119 def correct_arguments?(arguments); end - # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#141 + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#140 def override_by_legacy_args(kwargs, node); end end -# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#69 +# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#68 RuboCop::Cop::Lint::ErbNewArguments::MESSAGES = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#81 +# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#80 RuboCop::Cop::Lint::ErbNewArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Looks for uses of flip-flop operator @@ -18913,7 +18989,7 @@ RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String) # # format('Numbered format: %1$s and numbered %2$s', a_value, another) # -# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#38 +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#37 class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#100 def called_on_string?(param0 = T.unsafe(nil)); end @@ -19171,30 +19247,30 @@ RuboCop::Cop::Lint::HeredocMethodCallPosition::MSG = T.let(T.unsafe(nil), String # # good # foo.equal?(bar) # -# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#19 +# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#18 class RuboCop::Cop::Lint::IdentityComparison < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#25 + # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#24 def on_send(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#41 + # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#40 def compare_between_object_id_by_double_equal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#45 + # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#44 def object_id_method?(node); end end -# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#22 +# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#21 RuboCop::Cop::Lint::IdentityComparison::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#23 +# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#22 RuboCop::Cop::Lint::IdentityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for implicit string concatenation of string literals @@ -19255,7 +19331,10 @@ RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_METHOD = T.let(T.unsafe(nil # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#26 RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), String) -# This cop checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0. +# Checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0. +# +# When an array of IO objects waiting for an exception (the third argument of `IO.select`) +# is used as an argument, there is no alternative API, so offenses are not registered. # # NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`, # and the return value of `io.wait_readable` and `io.wait_writable` are `self`. @@ -19276,31 +19355,31 @@ RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), Stri # # good # io.wait_writable(timeout) # -# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#32 +# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#34 class RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#39 + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#41 def io_select(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#44 + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#46 def on_send(node); end private - # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#67 + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#69 def preferred_method(read, write, timeout); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#61 + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#63 def scheduler_compatible?(io1, io2); end end -# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#35 +# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#37 RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#36 +# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#38 RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for `private` or `protected` access modifiers which are @@ -19429,20 +19508,25 @@ class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#59 def on_class(node); end - # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#69 + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#70 def on_send(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#86 + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#87 def exception_class?(class_node); end - # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#82 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#91 + def inherit_exception_class_with_omitted_namespace?(class_node); end + + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#83 def message(node); end - # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#90 + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#99 def preferred_base_class; end end @@ -19492,7 +19576,7 @@ RuboCop::Cop::Lint::InterpolationCheck::MSG = T.let(T.unsafe(nil), String) # Checks uses of lambda without a literal block. # It emulates the following warning in Ruby 3.0: # -# % ruby -vwe 'lambda(&proc {})' +# $ ruby -vwe 'lambda(&proc {})' # ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19] # -e:1: warning: lambda without a literal block is deprecated; use the proc without # lambda instead @@ -19848,6 +19932,16 @@ RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), # missing method. In other cases, the theoretical ideal handling could be # challenging or verbose for no actual gain. # +# Autocorrection is not supported because the position of `super` cannot be +# determined automatically. +# +# `Object` and `BasicObject` are allowed by this cop because of their +# stateless nature. However, sometimes you might want to allow other parent +# classes from this cop, for example in the case of an abstract class that is +# not meant to be called with `super`. In those cases, you can use the +# `AllowedParentClasses` option to specify which classes should be allowed +# *in addition to* `Object` and `BasicObject`. +# # @example # # bad # class Employee < Person @@ -19894,63 +19988,148 @@ RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), # end # end # -# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#60 +# # good +# class ClassWithNoParent +# def initialize +# do_something +# end +# end +# @example AllowedParentClasses: [MyAbstractClass] +# # good +# class MyConcreteClass < MyAbstractClass +# def initialize +# do_something +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#85 class RuboCop::Cop::Lint::MissingSuper < ::RuboCop::Cop::Base - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#74 + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#99 def class_new_block(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#80 + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#105 def on_def(node); end - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#90 + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#115 def on_defs(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#102 + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#149 + def allowed_class?(node); end + + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#153 + def allowed_classes; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#127 def callback_method_def?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#108 + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#133 def contains_super?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#112 + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#137 def inside_class_with_stateful_parent?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#98 + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#123 def offender?(node); end - - # @return [Boolean] - # - # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#124 - def stateless_class?(node); end end -# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#71 +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#96 RuboCop::Cop::Lint::MissingSuper::CALLBACKS = T.let(T.unsafe(nil), Set) -# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#62 +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#87 RuboCop::Cop::Lint::MissingSuper::CALLBACK_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#66 +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#91 RuboCop::Cop::Lint::MissingSuper::CLASS_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#61 +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#86 RuboCop::Cop::Lint::MissingSuper::CONSTRUCTOR_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#67 +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#92 RuboCop::Cop::Lint::MissingSuper::METHOD_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#64 +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#89 RuboCop::Cop::Lint::MissingSuper::STATELESS_CLASSES = T.let(T.unsafe(nil), Array) +# Checks for mixed-case character ranges since they include likely unintended characters. +# +# Offenses are registered for regexp character classes like `/[A-z]/` +# as well as range objects like `('A'..'z')`. +# +# NOTE: Range objects cannot be autocorrected. +# +# @example +# +# # bad +# r = /[A-z]/ +# +# # good +# r = /[A-Za-z]/ +# +# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#28 +class RuboCop::Cop::Lint::MixedCaseRange < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#56 + def each_unsafe_regexp_range(node); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#37 + def on_erange(node); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#37 + def on_irange(node); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#48 + def on_regexp(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#72 + def build_source_range(range_start, range_end); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#76 + def range_for(char); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#82 + def range_pairs(expr); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#102 + def rewrite_regexp_range(source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#92 + def skip_expression?(expr); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#96 + def skip_range?(range_start, range_end); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#86 + def unsafe_range?(range_start, range_end); end +end + +# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#32 +RuboCop::Cop::Lint::MixedCaseRange::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#35 +RuboCop::Cop::Lint::MixedCaseRange::RANGES = T.let(T.unsafe(nil), Array) + # Do not mix named captures and numbered captures in a Regexp literal # because numbered capture is ignored if they're mixed. # Replace numbered captures with non-capturing groupings or @@ -20646,81 +20825,81 @@ class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedPattern extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#102 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#103 def on_send(node); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#92 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#93 def to_method(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#97 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#98 def to_method_symbol(param0 = T.unsafe(nil)); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#155 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#160 def allow_receiver?(receiver); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#167 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#172 def allowed_method_name?(name); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#177 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#182 def conversion_method?(method_name); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#141 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#146 def correct_method(node, receiver); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#145 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#150 def correct_sym_method(to_method); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#124 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#129 def handle_as_symbol(node); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#109 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#110 def handle_conversion_method(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#185 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#190 def ignored_class?(name); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#181 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#186 def ignored_classes; end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#150 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#155 def remove_parentheses(corrector, node); end - # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#171 + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#176 def top_receiver(node); end end -# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#88 +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#89 RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHODS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#78 +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#79 RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHOD_CLASS_MAPPING = T.let(T.unsafe(nil), Hash) -# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#89 +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#90 RuboCop::Cop::Lint::NumberConversion::METHODS = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#84 +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#85 RuboCop::Cop::Lint::NumberConversion::MSG = T.let(T.unsafe(nil), String) # Checks for uses of numbered parameter assignment. # It emulates the following warning in Ruby 2.7: # -# % ruby -ve '_1 = :value' +# $ ruby -ve '_1 = :value' # ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19] # -e:1: warning: `_1' is reserved for numbered parameter; consider another name # # Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0. # -# % ruby -ve '_1 = :value' +# $ ruby -ve '_1 = :value' # ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19] # -e:1: _1 is reserved for numbered parameter # @@ -20798,24 +20977,24 @@ RuboCop::Cop::Lint::OrAssignmentToConstant::MSG = T.let(T.unsafe(nil), String) # # frozen_string_literal: true # p [''.frozen?, ''.encoding] #=> [true, #] # -# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#33 +# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#32 class RuboCop::Cop::Lint::OrderedMagicComments < ::RuboCop::Cop::Base include ::RuboCop::Cop::FrozenStringLiteral extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#39 + # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#38 def on_new_investigation; end private - # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#56 + # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#55 def autocorrect(corrector, encoding_line, frozen_string_literal_line); end - # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#64 + # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#63 def magic_comment_lines; end end -# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#37 +# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#36 RuboCop::Cop::Lint::OrderedMagicComments::MSG = T.let(T.unsafe(nil), String) # Looks for references of Regexp captures that are out of range @@ -21441,6 +21620,79 @@ RuboCop::Cop::Lint::RedundantDirGlobSort::MSG = T.let(T.unsafe(nil), String) # source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#37 RuboCop::Cop::Lint::RedundantDirGlobSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Checks for redundant quantifiers inside Regexp literals. +# +# It is always allowed when interpolation is used in a regexp literal, +# because it's unknown what kind of string will be expanded as a result: +# +# [source,ruby] +# ---- +# /(?:a*#{interpolation})?/x +# ---- +# +# @example +# # bad +# /(?:x+)+/ +# +# # good +# /(?:x)+/ +# +# # good +# /(?:x+)/ +# +# # bad +# /(?:x+)?/ +# +# # good +# /(?:x)*/ +# +# # good +# /(?:x*)/ +# +# source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#34 +class RuboCop::Cop::Lint::RedundantRegexpQuantifiers < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#42 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#83 + def character_set?(expr); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#61 + def each_redundantly_quantified_pair(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#87 + def mergeable_quantifier(expr); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#103 + def merged_quantifier(exp1, exp2); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#119 + def message(group, child, replacement); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#115 + def quantifier_range(group, child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#75 + def redundant_group?(expr); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#79 + def redundantly_quantifiable?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#38 +RuboCop::Cop::Lint::RedundantRegexpQuantifiers::MSG_REDUNDANT_QUANTIFIER = T.let(T.unsafe(nil), String) + # Checks for unnecessary `require` statement. # # The following features are unnecessary `require` statement because @@ -21475,9 +21727,12 @@ class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#52 + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#57 def on_send(node); end + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#53 + def pp_const?(param0 = T.unsafe(nil)); end + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#47 def redundant_require_statement?(param0 = T.unsafe(nil)); end @@ -21485,13 +21740,13 @@ class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#71 - def redundant_feature?(feature_name); end + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#87 + def need_to_require_pp?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#82 - def use_pretty_print_method?; end + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#76 + def redundant_feature?(feature_name); end end # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#38 @@ -21723,7 +21978,7 @@ RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_I = T.let(T.unsafe(nil), St # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#76 RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_W = T.let(T.unsafe(nil), String) -# Checks for string conversion in string interpolation, +# Checks for string conversion in string interpolation, `print`, `puts`, and `warn` arguments, # which is redundant. # # @example @@ -21731,30 +21986,47 @@ RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_W = T.let(T.unsafe(nil), St # # bad # # "result is #{something.to_s}" +# print something.to_s +# puts something.to_s +# warn something.to_s # @example # # # good # # "result is #{something}" +# print something +# puts something +# warn something # -# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#20 +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#27 class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Base include ::RuboCop::Cop::Interpolation extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#30 + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#38 def on_interpolation(begin_node); end - # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#28 + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#46 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#36 def to_s_without_args?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#58 + def register_offense(node, context); end end -# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#24 +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#31 RuboCop::Cop::Lint::RedundantStringCoercion::MSG_DEFAULT = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#25 +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#32 RuboCop::Cop::Lint::RedundantStringCoercion::MSG_SELF = T.let(T.unsafe(nil), String) +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#33 +RuboCop::Cop::Lint::RedundantStringCoercion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Checks for redundant `with_index`. # # @example @@ -22445,7 +22717,7 @@ RuboCop::Cop::Lint::SelfAssignment::ASSIGNMENT_TYPE_TO_RHS_TYPE = T.let(T.unsafe # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#20 RuboCop::Cop::Lint::SelfAssignment::MSG = T.let(T.unsafe(nil), String) -# This cop checks for `send`, `public_send`, and `__send__` methods +# Checks for `send`, `public_send`, and `__send__` methods # when using mix-in. # # `include` and `prepend` methods were private methods until Ruby 2.0, @@ -22475,41 +22747,41 @@ RuboCop::Cop::Lint::SelfAssignment::MSG = T.let(T.unsafe(nil), String) # Foo.prepend Bar # Foo.extend Bar # -# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#37 +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#36 class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#54 + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#53 def on_send(node); end - # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#47 + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#46 def send_with_mixin_argument?(param0 = T.unsafe(nil)); end private - # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#68 + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#67 def bad_location(node); end - # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#74 + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#73 def message(method, module_name, bad_method); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#78 + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#77 def mixin_method?(node); end end -# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#42 +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#41 RuboCop::Cop::Lint::SendWithMixinArgument::MIXIN_METHODS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#41 +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#40 RuboCop::Cop::Lint::SendWithMixinArgument::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#44 +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#43 RuboCop::Cop::Lint::SendWithMixinArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#43 +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#42 RuboCop::Cop::Lint::SendWithMixinArgument::SEND_METHODS = T.let(T.unsafe(nil), Array) # Checks for shadowed arguments. @@ -22699,7 +22971,7 @@ class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#119 def evaluate_exceptions(group); end - # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#158 + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#152 def find_shadowing_rescue(rescues); end # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#84 @@ -22710,7 +22982,7 @@ class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#143 + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#137 def sorted?(rescued_groups); end # @return [Boolean] @@ -23093,41 +23365,47 @@ end # # # good # def foo(x, y = 1) +# # Alternatives to `__callee__` are `__method__` and `:foo`. # return to_enum(__callee__, x, y) -# # alternatives to `__callee__` are `__method__` and `:foo` # end # -# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#21 +# # good +# def foo(x, y = 1) +# # It is also allowed if it is wrapped in some method like Sorbet. +# return to_enum(T.must(__callee__), x, y) +# end +# +# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#27 class RuboCop::Cop::Lint::ToEnumArguments < ::RuboCop::Cop::Base - # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#27 + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#33 def enum_conversion_call?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#32 + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#38 def method_name?(param0 = T.unsafe(nil), param1); end - # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#41 + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#47 def on_send(node); end - # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#37 + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#43 def passing_keyword_arg?(param0 = T.unsafe(nil), param1); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#72 + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#78 def argument_match?(send_arg, def_arg); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#57 + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#63 def arguments_match?(arguments, def_node); end end -# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#22 +# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#28 RuboCop::Cop::Lint::ToEnumArguments::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#24 +# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#30 RuboCop::Cop::Lint::ToEnumArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks to make sure `#to_json` includes an optional argument. @@ -23171,27 +23449,39 @@ RuboCop::Cop::Lint::ToJSON::MSG = T.let(T.unsafe(nil), String) # always ignored. This is detected automatically since Ruby 2.7. # # @example +# # bad +# return 1 # -# # Detected since Ruby 2.7 -# return 1 # 1 is always ignored. +# # good +# return # -# source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#17 +# source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#16 class RuboCop::Cop::Lint::TopLevelReturnWithArgument < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#21 def on_return(return_node); end private + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#35 + def remove_arguments(corrector, return_node); end + + # This cop works by validating the ancestors of the return node. A + # top-level return node's ancestors should not be of block, def, or + # defs type. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#42 + def top_level_return?(return_node); end + # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#27 - def ancestors_valid?(return_node); end + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#31 + def top_level_return_with_any_argument?(return_node); end end -# This cop works by validating the ancestors of the return node. A -# top-level return node's ancestors should not be of block, def, or -# defs type. -# # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#19 RuboCop::Cop::Lint::TopLevelReturnWithArgument::MSG = T.let(T.unsafe(nil), String) @@ -24317,49 +24607,70 @@ RuboCop::Cop::Lint::UselessAccessModifier::MSG = T.let(T.unsafe(nil), String) # do_something(some_var) # end # -# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#33 +# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#39 class RuboCop::Cop::Lint::UselessAssignment < ::RuboCop::Cop::Base - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#40 + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#50 def after_leaving_scope(scope, _variable_table); end - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#44 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#136 + def autocorrect(corrector, assignment); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#54 def check_for_unused_assignments(variable); end - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#108 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#120 def collect_variable_like_names(scope); end - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#62 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#74 def message_for_useless_assignment(assignment); end - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#68 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#80 def message_specification(assignment, variable); end - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#78 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#90 def multiple_assignment_message(variable_name); end - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#83 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#95 def operator_assignment_message(scope, assignment); end + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#153 + def remove_exception_assignment_part(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#177 + def remove_local_variable_assignment_part(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#166 + def remove_trailing_character_from_operator(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#162 + def rename_variable_with_underscore(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#170 + def replace_named_capture_group_with_non_capturing_group(corrector, node, variable_name); end + # TODO: More precise handling (rescue, ensure, nested begin, etc.) # - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#98 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#110 def return_value_node_of_scope(scope); end - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#91 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#103 def similar_name_message(variable); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#117 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#129 def variable_like_method_invocation?(node); end class << self - # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#36 + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#46 def joining_forces; end end end -# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#34 +# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#44 RuboCop::Cop::Lint::UselessAssignment::MSG = T.let(T.unsafe(nil), String) # Checks for useless `else` in `begin..end` without `rescue`. @@ -24438,12 +24749,17 @@ class RuboCop::Cop::Lint::UselessMethodDefinition < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#57 + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#65 def delegating?(node, def_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#53 + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#57 + def method_definition_with_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#61 def use_rest_or_optional_args?(node); end end @@ -24801,87 +25117,99 @@ RuboCop::Cop::Lint::UselessTimes::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # # source://rubocop//lib/rubocop/cop/lint/void.rb#43 class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base - # source://rubocop//lib/rubocop/cop/lint/void.rb#76 + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/void.rb#80 def on_begin(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#67 + # source://rubocop//lib/rubocop/cop/lint/void.rb#71 def on_block(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#76 + # source://rubocop//lib/rubocop/cop/lint/void.rb#80 def on_kwbegin(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#67 + # source://rubocop//lib/rubocop/cop/lint/void.rb#71 def on_numblock(node); end private - # source://rubocop//lib/rubocop/cop/lint/void.rb#83 + # source://rubocop//lib/rubocop/cop/lint/void.rb#194 + def autocorrect_nonmutating_send(corrector, node, suggestion); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#190 + def autocorrect_void_expression(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#178 + def autocorrect_void_op(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#87 def check_begin(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#89 + # source://rubocop//lib/rubocop/cop/lint/void.rb#93 def check_expression(expr); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#112 + # source://rubocop//lib/rubocop/cop/lint/void.rb#128 def check_literal(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#130 + # source://rubocop//lib/rubocop/cop/lint/void.rb#152 def check_nonmutating(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#118 + # source://rubocop//lib/rubocop/cop/lint/void.rb#136 def check_self(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#106 + # source://rubocop//lib/rubocop/cop/lint/void.rb#113 def check_var(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#124 + # source://rubocop//lib/rubocop/cop/lint/void.rb#144 def check_void_expression(node); end - # source://rubocop//lib/rubocop/cop/lint/void.rb#100 + # source://rubocop//lib/rubocop/cop/lint/void.rb#104 def check_void_op(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/lint/void.rb#141 + # source://rubocop//lib/rubocop/cop/lint/void.rb#170 def in_void_context?(node); end end -# source://rubocop//lib/rubocop/cop/lint/void.rb#51 +# source://rubocop//lib/rubocop/cop/lint/void.rb#55 RuboCop::Cop::Lint::Void::BINARY_OPERATORS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/void.rb#48 +# source://rubocop//lib/rubocop/cop/lint/void.rb#52 RuboCop::Cop::Lint::Void::EXPRESSION_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/void.rb#46 +# source://rubocop//lib/rubocop/cop/lint/void.rb#50 RuboCop::Cop::Lint::Void::LIT_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/void.rb#62 -RuboCop::Cop::Lint::Void::METHODS_REPLACABLE_BY_EACH = T.let(T.unsafe(nil), Array) +# source://rubocop//lib/rubocop/cop/lint/void.rb#66 +RuboCop::Cop::Lint::Void::METHODS_REPLACEABLE_BY_EACH = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/void.rb#64 +# source://rubocop//lib/rubocop/cop/lint/void.rb#68 RuboCop::Cop::Lint::Void::NONMUTATING_METHODS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/void.rb#55 +# source://rubocop//lib/rubocop/cop/lint/void.rb#59 RuboCop::Cop::Lint::Void::NONMUTATING_METHODS_WITH_BANG_VERSION = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/void.rb#49 +# source://rubocop//lib/rubocop/cop/lint/void.rb#53 RuboCop::Cop::Lint::Void::NONMUTATING_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/void.rb#53 +# source://rubocop//lib/rubocop/cop/lint/void.rb#57 RuboCop::Cop::Lint::Void::OPERATORS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/void.rb#44 +# source://rubocop//lib/rubocop/cop/lint/void.rb#48 RuboCop::Cop::Lint::Void::OP_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/void.rb#47 +# source://rubocop//lib/rubocop/cop/lint/void.rb#51 RuboCop::Cop::Lint::Void::SELF_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/void.rb#52 +# source://rubocop//lib/rubocop/cop/lint/void.rb#56 RuboCop::Cop::Lint::Void::UNARY_OPERATORS = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/lint/void.rb#45 +# source://rubocop//lib/rubocop/cop/lint/void.rb#49 RuboCop::Cop::Lint::Void::VAR_MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/lint/void.rb#54 +# source://rubocop//lib/rubocop/cop/lint/void.rb#58 RuboCop::Cop::Lint::Void::VOID_CONTEXT_TYPES = T.let(T.unsafe(nil), Array) # Common functionality for obtaining source ranges from regexp matches @@ -25276,15 +25604,18 @@ RuboCop::Cop::Metrics::BlockNesting::NESTING_BLOCKS = T.let(T.unsafe(nil), Array class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Base include ::RuboCop::Cop::CodeLength - # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#46 + # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#47 def on_casgn(node); end # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#42 def on_class(node); end + # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#42 + def on_sclass(node); end + private - # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#64 + # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#65 def message(length, max_length); end end @@ -25712,7 +26043,7 @@ class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#128 + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#127 def argument?(node); end # @return [Boolean] @@ -25722,7 +26053,7 @@ class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#124 + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#123 def branch?(node); end # @return [Boolean] @@ -25735,7 +26066,7 @@ class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#132 + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#131 def condition?(node); end # @return [Boolean] @@ -25788,18 +26119,18 @@ class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#175 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#182 def another_args?(node); end # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#42 def build_foldable_checks(types); end - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#83 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#90 def classlike_code_length(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#131 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#138 def classlike_node?(node); end # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#66 @@ -25807,53 +26138,61 @@ class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#156 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#163 def count_comments?; end - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#119 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#126 def each_top_level_descendant(node, types, &block); end - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#139 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#146 def extract_body(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#135 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#142 def foldable_node?(node); end - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#114 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#121 def heredoc_length(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#79 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#86 def heredoc_node?(node); end # Returns true for lines that shall not be included in the count. # # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#152 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#159 def irrelevant_line?(source_line); end - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#103 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#110 def line_numbers_of_inner_nodes(node, *types); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#99 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#106 def namespace_module?(node); end + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#186 + def node_with_heredoc?(node); end + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#60 def normalize_foldable_types(types); end - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#160 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#167 def omit_length(descendant); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#171 + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#178 def parenthesized?(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#190 + def source_from_node_with_heredoc(node); end end # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#13 @@ -27093,6 +27432,7 @@ RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String) # Recommends the use of inclusive language instead of problematic terms. # The cop can check the following locations for offenses: +# # - identifiers # - constants # - variables @@ -27100,6 +27440,7 @@ RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String) # - symbols # - comments # - file paths +# # Each of these locations can be individually enabled/disabled via configuration, # for example CheckIdentifiers = true/false. # @@ -27110,6 +27451,9 @@ RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String) # `WholeWord: true` can be set on a flagged term to indicate the cop should only match when # a term matches the whole word (partial matches will not be offenses). # +# The cop supports autocorrection when there is only one suggestion. When there are multiple +# suggestions, the best suggestion cannot be identified and will not be autocorrected. +# # @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } } # # Suggest replacing identifier whitelist with allowlist # @@ -27151,93 +27495,97 @@ RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String) # # good (won't be flagged despite containing `slave`) # TeslaVehicle # -# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#69 +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#74 class RuboCop::Cop::Naming::InclusiveLanguage < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector # @return [InclusiveLanguage] a new instance of InclusiveLanguage # - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#78 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#84 def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#87 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#93 def on_new_investigation; end private - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#105 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#111 def add_offenses_for_token(token, word_locations); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#154 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#167 def add_to_flagged_term_hash(regex_string, term, term_definition); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#180 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#193 def array_to_ignorecase_regex(strings); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#113 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#126 def check_token?(type); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#231 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#244 def create_message(word, message = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#205 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#218 def create_multiple_word_message_for_file(words); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#201 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#214 def create_single_word_message_for_file(word); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#176 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#189 def ensure_regex_string(regex); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#147 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#160 def extract_regexp(term, term_definition); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#239 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#252 def find_flagged_term(word); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#253 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#266 def format_suggestions(suggestions); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#184 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#197 def investigate_filepath; end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#94 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#100 def investigate_tokens; end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#219 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#232 def mask_input(str); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#117 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#281 + def offense_range(token, word); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#130 def preprocess_check_config; end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#131 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#144 def preprocess_flagged_terms; end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#246 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#259 def preprocess_suggestions(suggestions); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#166 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#179 def process_allowed_regex(allowed); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#209 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#222 def scan_for_words(input); end - # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#161 + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#174 def set_regexes(flagged_term_strings, allowed_strings); end end -# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#72 +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#78 RuboCop::Cop::Naming::InclusiveLanguage::EMPTY_ARRAY = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#73 +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#79 RuboCop::Cop::Naming::InclusiveLanguage::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#74 +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#80 RuboCop::Cop::Naming::InclusiveLanguage::MSG_FOR_FILE_PATH = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#76 +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#82 class RuboCop::Cop::Naming::InclusiveLanguage::WordLocation < ::Struct # Returns the value of attribute position # @@ -27405,54 +27753,55 @@ end # @_foo ||= calculate_expensive_thing # end # -# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#147 +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#148 class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#189 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#197 def defined_memoized?(param0 = T.unsafe(nil), param1); end - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#157 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#160 def method_definition?(param0 = T.unsafe(nil)); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#197 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#205 def on_defined?(node); end - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#166 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#170 def on_or_asgn(node); end private - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#227 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#242 def find_definition(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#238 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#253 def matches?(method_name, ivar_assign); end - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#248 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#263 def message(variable); end - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#223 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#238 def style_parameter_name; end - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#256 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#271 def suggested_var(method_name); end - # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#262 + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#277 def variable_name_candidates(method_name); end end -# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#154 +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#157 RuboCop::Cop::Naming::MemoizedInstanceVariableName::DYNAMIC_DEFINE_METHODS = T.let(T.unsafe(nil), Set) -# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#150 +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#153 RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#152 +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#155 RuboCop::Cop::Naming::MemoizedInstanceVariableName::UNDERSCORE_REQUIRED = T.let(T.unsafe(nil), String) # Makes sure that all methods use the configured style, @@ -27724,36 +28073,39 @@ class RuboCop::Cop::Naming::RescuedExceptionsVariableName < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#108 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#96 + def autocorrect(corrector, node, range, offending_name, preferred_name); end + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#116 def correct_node(corrector, node, offending_name, preferred_name); end # If the exception variable is reassigned, that assignment needs to be corrected. # Further `lvar` nodes will not be corrected though since they now refer to a # different variable. # - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#126 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#134 def correct_reassignment(corrector, node, offending_name, preferred_name); end - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#151 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#159 def message(node); end - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#93 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#91 def offense_range(resbody); end - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#135 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#143 def preferred_name(variable_name); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#157 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#165 def shadowed_variable_name?(node); end - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#144 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#152 def variable_name(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#98 + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#106 def variable_name_matches?(node, name); end end @@ -27775,11 +28127,14 @@ RuboCop::Cop::Naming::RescuedExceptionsVariableName::MSG = T.let(T.unsafe(nil), # # # good # fooBar = 1 +# @example AllowedIdentifiers: ['fooBar'] +# # good (with EnforcedStyle: snake_case) +# fooBar = 1 # @example AllowedPatterns: ['_v\d+\z'] -# # good +# # good (with EnforcedStyle: camelCase) # :release_v1 # -# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#26 +# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#31 class RuboCop::Cop::Naming::VariableName < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedIdentifiers include ::RuboCop::Cop::ConfigurableEnforcedStyle @@ -27787,51 +28142,51 @@ class RuboCop::Cop::Naming::VariableName < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableNaming include ::RuboCop::Cop::AllowedPattern - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_arg(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_blockarg(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_cvasgn(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_ivasgn(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_kwarg(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_kwoptarg(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_kwrestarg(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_lvar(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_lvasgn(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_optarg(node); end - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#37 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 def on_restarg(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#33 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#38 def valid_name?(node, name, given_style = T.unsafe(nil)); end private - # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#57 + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#62 def message(style); end end -# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#31 +# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#36 RuboCop::Cop::Naming::VariableName::MSG = T.let(T.unsafe(nil), String) # Makes sure that all numbered variables use the @@ -28571,7 +28926,7 @@ class RuboCop::Cop::PercentLiteralCorrector def fix_escaped_content(word_node, escape, delimiters); end # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#69 - def line_breaks(node, source, previous_line_num, base_line_num, node_indx); end + def line_breaks(node, source, previous_line_num, base_line_num, node_index); end # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#38 def new_contents(node, escape, delimiters); end @@ -29892,29 +30247,29 @@ class RuboCop::Cop::Style::AccessorGrouping < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#71 def check(send_node); end - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#110 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#114 def class_send_elements(class_node); end - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#153 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#157 def group_accessors(node, accessors); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#95 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#96 def groupable_accessor?(node); end - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#130 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#134 def groupable_sibling_accessors(send_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#122 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#126 def grouped_style?; end - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#139 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#143 def message(send_node); end - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#144 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#148 def preferred_accessors(node); end # @return [Boolean] @@ -29922,12 +30277,12 @@ class RuboCop::Cop::Style::AccessorGrouping < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#91 def previous_line_comment?(node); end - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#159 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#163 def separate_accessors(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#126 + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#130 def separated_style?; end end @@ -30411,7 +30766,7 @@ class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/attr.rb#64 + # source://rubocop//lib/rubocop/cop/style/attr.rb#74 def class_eval?(param0 = T.unsafe(nil)); end # source://rubocop//lib/rubocop/cop/style/attr.rb#24 @@ -30419,13 +30774,23 @@ class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base private + # @return [Boolean] + # # source://rubocop//lib/rubocop/cop/style/attr.rb#37 + def allowed_context?(node); end + + # source://rubocop//lib/rubocop/cop/style/attr.rb#47 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/attr.rb#49 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/attr.rb#43 + def define_attr_method?(node); end + + # source://rubocop//lib/rubocop/cop/style/attr.rb#59 def message(node); end - # source://rubocop//lib/rubocop/cop/style/attr.rb#53 + # source://rubocop//lib/rubocop/cop/style/attr.rb#63 def replacement_method(node); end end @@ -30523,19 +30888,19 @@ end # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#30 RuboCop::Cop::Style::BarePercentLiterals::MSG = T.let(T.unsafe(nil), String) -# This cop checks for BEGIN blocks. +# Checks for BEGIN blocks. # # @example # # bad # BEGIN { test } # -# source://rubocop//lib/rubocop/cop/style/begin_block.rb#13 +# source://rubocop//lib/rubocop/cop/style/begin_block.rb#12 class RuboCop::Cop::Style::BeginBlock < ::RuboCop::Cop::Base - # source://rubocop//lib/rubocop/cop/style/begin_block.rb#16 + # source://rubocop//lib/rubocop/cop/style/begin_block.rb#15 def on_preexe(node); end end -# source://rubocop//lib/rubocop/cop/style/begin_block.rb#14 +# source://rubocop//lib/rubocop/cop/style/begin_block.rb#13 RuboCop::Cop::Style::BeginBlock::MSG = T.let(T.unsafe(nil), String) # Checks for places where `attr_reader` and `attr_writer` @@ -31064,27 +31429,27 @@ RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(n # Corrector to correct conditional assignment in `case` statements. # -# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#603 +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#605 class RuboCop::Cop::Style::CaseCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#608 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#610 def correct(corrector, cop, node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#618 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#620 def move_assignment_inside_condition(corrector, node); end private - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#638 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#640 def extract_branches(case_node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#632 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#634 def extract_tail_branches(node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#648 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#650 def move_branch_inside_condition(corrector, branch, condition, assignment, column); end end end @@ -31463,7 +31828,7 @@ RuboCop::Cop::Style::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Enforces the use of `Object#instance_of?` instead of class comparison # for equality. -# `==`, `equal?`, and `eql?` methods are allowed by default. +# `==`, `equal?`, and `eql?` custom method definitions are allowed by default. # These are customizable with `AllowedMethods` option. # # @example @@ -31475,69 +31840,77 @@ RuboCop::Cop::Style::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # # # good # var.instance_of?(Date) -# @example AllowedMethods: [] (default) +# @example AllowedMethods: ['==', 'equal?', 'eql?'] (default) # # good -# var.instance_of?(Date) +# def ==(other) +# self.class == other.class && name == other.name +# end # -# # bad -# var.class == Date -# var.class.equal?(Date) -# var.class.eql?(Date) -# var.class.name == 'Date' -# @example AllowedMethods: [`==`] -# # good -# var.instance_of?(Date) -# var.class == Date -# var.class.name == 'Date' +# def equal?(other) +# self.class.equal?(other.class) && name.equal?(other.name) +# end # -# # bad -# var.class.equal?(Date) -# var.class.eql?(Date) +# def eql?(other) +# self.class.eql?(other.class) && name.eql?(other.name) +# end # @example AllowedPatterns: [] (default) -# # good -# var.instance_of?(Date) -# # # bad -# var.class == Date -# var.class.equal?(Date) -# var.class.eql?(Date) -# var.class.name == 'Date' +# def eq(other) +# self.class.eq(other.class) && name.eq(other.name) +# end # @example AllowedPatterns: ['eq'] # # good -# var.instance_of?(Date) -# var.class.equal?(Date) -# var.class.eql?(Date) -# -# # bad -# var.class == Date -# var.class.name == 'Date' +# def eq(other) +# self.class.eq(other.class) && name.eq(other.name) +# end # -# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#61 +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#47 class RuboCop::Cop::Style::ClassEqualityComparison < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::AllowedPattern extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#72 + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#59 def class_comparison_candidate?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#78 + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#65 def on_send(node); end private - # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#96 + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#85 def class_name(class_node, node); end - # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#110 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#105 + def class_name_method?(method_name); end + + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#121 def offense_range(receiver_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#109 + def require_cbase?(class_node); end + + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#117 + def trim_string_quotes(class_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#113 + def unable_to_determine_type?(class_node); end end -# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#67 +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#56 +RuboCop::Cop::Style::ClassEqualityComparison::CLASS_NAME_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#53 RuboCop::Cop::Style::ClassEqualityComparison::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#69 +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#55 RuboCop::Cop::Style::ClassEqualityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for uses of the class/module name instead of @@ -31744,7 +32117,9 @@ RuboCop::Cop::Style::ClassVars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # @example # # bad # array.reject(&:nil?) +# array.delete_if(&:nil?) # array.reject { |e| e.nil? } +# array.delete_if { |e| e.nil? } # array.select { |e| !e.nil? } # # # good @@ -31757,48 +32132,53 @@ RuboCop::Cop::Style::ClassVars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # # # good # hash.compact! +# @example AllowedReceivers: ['params'] +# # good +# params.reject(&:nil?) # -# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#36 +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#42 class RuboCop::Cop::Style::CollectionCompact < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedReceivers include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#72 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#82 def on_send(node); end - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#52 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#62 def reject_method?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#45 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#55 def reject_method_with_block_pass?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#62 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#72 def select_method?(param0 = T.unsafe(nil)); end private - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#106 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#119 def good_method_name(node); end - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#84 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#97 def offense_range(node); end - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#114 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#127 def range(begin_pos_node, end_pos_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#100 + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#113 def to_enum_method?(node); end end -# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#40 +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#48 RuboCop::Cop::Style::CollectionCompact::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#41 +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#49 RuboCop::Cop::Style::CollectionCompact::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#42 +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#50 RuboCop::Cop::Style::CollectionCompact::TO_ENUM_METHODS = T.let(T.unsafe(nil), Array) # Enforces the use of consistent method names @@ -31868,8 +32248,8 @@ end # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#45 RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String) -# Checks for methods invoked via the :: operator instead -# of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir). +# Checks for methods invoked via the `::` operator instead +# of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`). # # @example # # bad @@ -31979,29 +32359,40 @@ RuboCop::Cop::Style::ColonMethodDefinition::MSG = T.let(T.unsafe(nil), String) # # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#59 class RuboCop::Cop::Style::CombinableLoops < ::RuboCop::Cop::Base - # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#62 + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#66 def on_block(node); end - # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#71 + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#78 def on_for(node); end - # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#62 + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#66 def on_numblock(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#80 + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#89 def collection_looping_method?(node); end + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#105 + def combine_with_left_sibling(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#94 + def same_collection_looping_block?(node, sibling); end + # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#86 - def same_collection_looping?(node, sibling); end + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#101 + def same_collection_looping_for?(node, sibling); end end -# source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#60 +# source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#64 RuboCop::Cop::Style::CombinableLoops::MSG = T.let(T.unsafe(nil), String) # Enforces using `` or %x around command literals. @@ -32771,22 +33162,22 @@ RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), # # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#440 module RuboCop::Cop::Style::ConditionalCorrectorHelper - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#459 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#461 def assignment(node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#489 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#491 def correct_branches(corrector, branches); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#466 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#468 def correct_if_branches(corrector, cop, node); end # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#441 def remove_whitespace_in_branches(corrector, branch, condition, column); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#476 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#478 def replace_branch_assignment(corrector, branch); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#452 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#454 def white_space_range(node, column); end end @@ -32871,55 +33262,96 @@ end # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#48 RuboCop::Cop::Style::ConstantVisibility::MSG = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/copyright.rb#18 +# source://rubocop//lib/rubocop/cop/style/copyright.rb#21 class RuboCop::Cop::Style::Copyright < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/copyright.rb#25 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#28 def on_new_investigation; end private - # source://rubocop//lib/rubocop/cop/style/copyright.rb#44 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#47 def autocorrect_notice; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/copyright.rb#75 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#78 def encoding_token?(processed_source, token_index); end - # source://rubocop//lib/rubocop/cop/style/copyright.rb#61 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#64 def insert_notice_before(processed_source); end - # source://rubocop//lib/rubocop/cop/style/copyright.rb#40 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#43 def notice; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/copyright.rb#82 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#85 def notice_found?(processed_source); end - # source://rubocop//lib/rubocop/cop/style/copyright.rb#48 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#51 def offense_range; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/copyright.rb#68 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#71 def shebang_token?(processed_source, token_index); end # @raise [Warning] # - # source://rubocop//lib/rubocop/cop/style/copyright.rb#52 + # source://rubocop//lib/rubocop/cop/style/copyright.rb#55 def verify_autocorrect_notice!; end end -# source://rubocop//lib/rubocop/cop/style/copyright.rb#23 +# source://rubocop//lib/rubocop/cop/style/copyright.rb#26 RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/copyright.rb#22 +# source://rubocop//lib/rubocop/cop/style/copyright.rb#25 RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String) +# Checks for inheritance from `Data.define` to avoid creating the anonymous parent class. +# +# @example +# # bad +# class Person < Data.define(:first_name, :last_name) +# def age +# 42 +# end +# end +# +# # good +# Person = Data.define(:first_name, :last_name) do +# def age +# 42 +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#26 +class RuboCop::Cop::Style::DataInheritance < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#48 + def data_define?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#36 + def on_class(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#55 + def correct_parent(parent, corrector); end + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#65 + def range_for_empty_class_body(class_node, data_define); end +end + +# source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#31 +RuboCop::Cop::Style::DataInheritance::MSG = T.let(T.unsafe(nil), String) + # Checks for consistent usage of the `DateTime` class over the # `Time` class. This cop is disabled by default since these classes, # although highly overlapping, have particularities that make them not @@ -33040,7 +33472,7 @@ end # source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#45 RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String) -# Checks for places where the `#__dir__` method can replace more +# Checks for places where the `#\_\_dir\_\_` method can replace more # complex constructs to retrieve a canonicalized absolute path to the # current file. # @@ -33099,12 +33531,12 @@ class RuboCop::Cop::Style::DirEmpty < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#28 def offensive?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#39 + # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#37 def on_send(node); end private - # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#51 + # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#48 def bang(node); end end @@ -33653,7 +34085,7 @@ class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Base # @return [Boolean] # # source://rubocop//lib/rubocop/cop/style/double_negation.rb#111 - def define_mehod?(node); end + def define_method?(node); end # @return [Boolean] # @@ -34523,12 +34955,12 @@ RuboCop::Cop::Style::EnvHome::MSG = T.let(T.unsafe(nil), String) RuboCop::Cop::Style::EnvHome::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Ensures that eval methods (`eval`, `instance_eval`, `class_eval` -# and `module_eval`) are given filename and line number values (`__FILE__` -# and `__LINE__`). This data is used to ensure that any errors raised +# and `module_eval`) are given filename and line number values (`\_\_FILE\_\_` +# and `\_\_LINE\_\_`). This data is used to ensure that any errors raised # within the evaluated code will be given the correct identification # in a backtrace. # -# The cop also checks that the line number given relative to `__LINE__` is +# The cop also checks that the line number given relative to `\_\_LINE\_\_` is # correct. # # This cop will autocorrect incorrect or missing filename and line number @@ -34701,6 +35133,52 @@ RuboCop::Cop::Style::EvenOdd::MSG = T.let(T.unsafe(nil), String) # source://rubocop//lib/rubocop/cop/style/even_odd.rb#22 RuboCop::Cop::Style::EvenOdd::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Checks for exact regexp match inside Regexp literals. +# +# @example +# +# # bad +# string =~ /\Astring\z/ +# string === /\Astring\z/ +# string.match(/\Astring\z/) +# string.match?(/\Astring\z/) +# +# # good +# string == 'string' +# +# # bad +# string !~ /\Astring\z/ +# +# # good +# string != 'string' +# +# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#25 +class RuboCop::Cop::Style::ExactRegexpMatch < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#32 + def exact_regexp_match(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#40 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#55 + def exact_match_pattern?(parsed_regexp); end + + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#62 + def new_method(node); end +end + +# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#28 +RuboCop::Cop::Style::ExactRegexpMatch::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#29 +RuboCop::Cop::Style::ExactRegexpMatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Checks for use of the `File.expand_path` arguments. # Likewise, it also checks for the `Pathname.new` argument. # @@ -35990,28 +36468,28 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#247 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#249 def accepted_form?(node, ending: T.unsafe(nil)); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#255 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#257 def accepted_if?(node, ending); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#269 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#271 def allowed_consecutive_conditionals?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#237 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#239 def and_or_guard_clause?(guard_clause); end # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#184 def autocorrect(corrector, node, condition, replacement, guard); end - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#208 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#210 def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard); end # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#133 @@ -36025,31 +36503,31 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#154 def consecutive_conditionals?(parent, node); end - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#229 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#231 def guard_clause_source(guard_clause); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#204 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#206 def heredoc?(argument); end - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#220 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#222 def range_of_branch_to_remove(node, guard); end # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#162 def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#265 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#267 def remove_whole_lines(corrector, range); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#242 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#244 def too_long_for_single_line?(node, example); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#251 + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#253 def trivial?(node); end end @@ -36225,68 +36703,58 @@ RuboCop::Cop::Style::HashConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr # # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#30 class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedReceivers include ::RuboCop::Cop::Lint::UnusedArgument extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#37 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#38 def kv_each(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#42 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#43 def kv_each_with_block_pass(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#46 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#47 def on_block(node); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#54 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#55 def on_block_pass(node); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#46 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#47 def on_numblock(node); end private - # @return [Boolean] - # - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#120 - def allowed_receiver?(receiver); end - - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#138 - def allowed_receivers; end - - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#85 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#86 def check_argument(variable); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#109 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#110 def correct_args(node, corrector); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#95 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#96 def correct_implicit(node, corrector, method_name); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#100 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#101 def correct_key_value_each(node, corrector); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#81 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#82 def format_message(method_name); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#116 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#117 def kv_range(outer_node); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#126 - def receiver_name(receiver); end - - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#62 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#63 def register_kv_offense(target, method); end - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#71 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#72 def register_kv_with_block_pass_offense(node, target, method); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#91 + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#92 def used?(arg); end end -# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#34 +# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#35 RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String) # Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods @@ -36331,42 +36799,42 @@ class RuboCop::Cop::Style::HashExcept < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#92 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#93 def bad_method?(block); end - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#154 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#165 def decorate_source(value); end - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#162 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#173 def except_key(node); end - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#141 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#152 def except_key_source(key); end - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#135 - def extract_body_if_nagated(body); end + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#146 + def extract_body_if_negated(body); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#116 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#127 def included?(negated, body); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#120 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#131 def not_included?(negated, body); end - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#171 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#182 def offense_range(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#124 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#135 def safe_to_register_offense?(block, except_key); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_except.rb#100 + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#111 def semantically_except_method?(send, block); end end @@ -36515,6 +36983,9 @@ RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String) # {foo: foo, bar: bar} # # # good +# {foo: foo, bar:} +# +# # good # {foo:, bar:} # @example EnforcedStyle: ruby19 (default) # # bad @@ -36526,88 +36997,88 @@ RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String) # {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol # {d: 1, 'e' => 2} # technically not forbidden # -# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#110 +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#113 class RuboCop::Cop::Style::HashSyntax < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::HashShorthandSyntax include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#164 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#167 def alternative_style; end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#142 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#145 def hash_rockets_check(pairs); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#156 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#159 def no_mixed_keys_check(pairs); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#120 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#123 def on_hash(node); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#138 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#141 def ruby19_check(pairs); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#146 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#149 def ruby19_no_mixed_keys_check(pairs); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#195 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#198 def acceptable_19_syntax_symbol?(sym_name); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#249 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#252 def argument_without_space?(node); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#175 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#178 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#253 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#256 def autocorrect_hash_rockets(corrector, pair_node); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#262 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#265 def autocorrect_no_mixed_keys(corrector, pair_node); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#228 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#231 def autocorrect_ruby19(corrector, pair_node); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#213 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#216 def check(pairs, delim, msg); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#270 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#273 def force_hash_rockets?(pairs); end - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#241 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#244 def range_for_autocorrect_ruby19(pair_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#185 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#188 def sym_indices?(pairs); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#189 + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#192 def word_symbol_pair?(pair); end end -# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#116 +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#119 RuboCop::Cop::Style::HashSyntax::MSG_19 = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#118 +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#121 RuboCop::Cop::Style::HashSyntax::MSG_HASH_ROCKETS = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#117 +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#120 RuboCop::Cop::Style::HashSyntax::MSG_NO_MIXED_KEYS = T.let(T.unsafe(nil), String) -# Looks for uses of `_.each_with_object({}) {...}`, -# `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just +# Looks for uses of `\_.each_with_object({}) {...}`, +# `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just # transforming the keys of a hash, and tries to use a simpler & faster # call to `transform_keys` instead. # It should only be enabled on Ruby version 2.5 or newer. @@ -36651,8 +37122,8 @@ class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Base def new_method_name; end end -# Looks for uses of `_.each_with_object({}) {...}`, -# `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just +# Looks for uses of `\_.each_with_object({}) {...}`, +# `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just # transforming the values of a hash, and tries to use a simpler & faster # call to `transform_values` instead. # @@ -36800,7 +37271,7 @@ class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#140 def check_branches(node, branches); end - # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#167 + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#168 def check_expressions(node, expressions, insert_position); end # @return [Boolean] @@ -36811,26 +37282,26 @@ class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base # `elsif` branches show up in the if node as nested `else` branches. We # need to recursively iterate over all `else` branches. # - # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#204 + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#208 def expand_elses(branch); end - # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#219 + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#223 def head(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#188 + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#192 def last_child_of_parent?(node); end - # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#198 + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#202 def message(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#194 + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#198 def single_child_branch?(branch_node); end - # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#215 + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#219 def tail(node); end end @@ -36839,24 +37310,24 @@ RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), St # Corrector to correct conditional assignment in `if` statements. # -# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#558 +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#560 class RuboCop::Cop::Style::IfCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#563 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#565 def correct(corrector, cop, node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#567 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#569 def move_assignment_inside_condition(corrector, node); end private - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#581 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#583 def extract_tail_branches(node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#588 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#590 def move_branch_inside_condition(corrector, branch, condition, assignment, column); end end end @@ -36919,43 +37390,43 @@ class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#67 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#69 def on_if(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#144 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#150 def allow_if_modifier?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#140 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#146 def allow_if_modifier_in_else_branch?(else_branch); end - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#82 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#88 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#111 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#117 def correct_to_elsif_from_if_inside_else_form(corrector, node, condition); end - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#103 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#109 def correct_to_elsif_from_modifier_form(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#129 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#135 def find_end_range(node); end - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#136 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#142 def if_condition_range(node, condition); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#125 + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#131 def then?(node); end end -# source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#65 +# source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#66 RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) # Checks for `if` and `unless` statements that would fit on one line if @@ -36966,6 +37437,18 @@ RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) # cop. The tab size is configured in the `IndentationWidth` of the # `Layout/IndentationStyle` cop. # +# One-line pattern matching is always allowed. To ensure that there are few cases +# where the match variable is not used, and to prevent oversights. The variable `x` +# becomes undefined and raises `NameError` when the following example is changed to +# the modifier form: +# +# [source,ruby] +# ---- +# if [42] in [x] +# x # `x` is undefined when using modifier form. +# end +# ---- +# # NOTE: It is allowed when `defined?` argument has an undefined value, # because using the modifier form causes the following incompatibility: # @@ -37004,7 +37487,7 @@ RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) # do_something # end # -# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#51 +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#63 class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp @@ -37014,114 +37497,120 @@ class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::CommentsHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#68 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#80 def on_if(node); end private - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#142 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#171 def allowed_patterns; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#202 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#231 def another_statement_on_same_line?(node); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#103 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#132 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#256 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#285 def comment_on_node_line(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#93 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#104 def defined_argument_is_undefined?(if_node, defined_node); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#85 - def defined_nodes(node); end + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#96 + def defined_nodes(condition); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#243 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#272 def extract_heredoc_from(last_argument); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#186 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#215 def line_length_enabled_at_line?(line); end + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#124 + def message(node); end + # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#190 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#219 def named_capture_in_condition?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#194 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#223 def non_eligible_node?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#198 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#227 def non_simple_if_unless?(node); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#260 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#114 + def pattern_matching_nodes(condition); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#289 def remove_comment(corrector, _node, comment); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#250 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#279 def remove_heredoc(corrector, heredoc); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#112 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#141 def replacement_for_modifier_form(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#236 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#265 def to_modifier_form_with_move_comment(node, indentation, comment); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#216 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#245 def to_normal_form(node, indentation); end - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#224 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#253 def to_normal_form_with_heredoc(node, indentation, heredoc); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#136 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#165 def too_long_due_to_comment_after_modifier?(node, comment); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#131 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#160 def too_long_due_to_modifier?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#177 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#206 def too_long_line_based_on_allow_uri?(line); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#160 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#189 def too_long_line_based_on_config?(range, line); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#169 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#198 def too_long_line_based_on_ignore_cop_directives?(range, line); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#147 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#176 def too_long_single_line?(node); end class << self - # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#64 + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#76 def autocorrect_incompatible_with; end end end -# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#59 +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#71 RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#62 +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#74 RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String) # Checks for if and unless statements used as modifiers of other if or @@ -37599,12 +38088,16 @@ RuboCop::Cop::Style::InverseMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr # Methods that can be inverted should be defined in `InverseMethods`. Note that # the relationship of inverse methods needs to be defined in both directions. # For example, -# InverseMethods: -# :!=: :== -# :even?: :odd? -# :odd?: :even? # -# will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`). +# [source,yaml] +# ---- +# InverseMethods: +# :!=: :== +# :even?: :odd? +# :odd?: :even? +# ---- +# +# will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`). # # @example # # bad (simple condition) @@ -37628,36 +38121,36 @@ RuboCop::Cop::Style::InverseMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr # # good (if) # foo if !condition # -# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#47 +# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#51 class RuboCop::Cop::Style::InvertibleUnlessCondition < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#52 + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#56 def on_if(node); end private - # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#87 + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#91 def autocorrect(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#100 + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#104 def autocorrect_send_node(corrector, node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#81 + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#85 def inheritance_check?(node); end - # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#108 + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#112 def inverse_methods; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#66 + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#70 def invertible?(node); end end -# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#50 +# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#54 RuboCop::Cop::Style::InvertibleUnlessCondition::MSG = T.let(T.unsafe(nil), String) # Checks for hardcoded IP addresses, which can make code @@ -38181,10 +38674,10 @@ class RuboCop::Cop::Style::MagicCommentFormat::CommentRange # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#125 def directives; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def loc(*args, **_arg1, &block); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def text(*args, **_arg1, &block); end # A magic comment can contain one value (normal style) or @@ -38314,12 +38807,12 @@ class RuboCop::Cop::Style::MapToHash < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#41 def map_to_h?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#45 + # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#48 def on_send(node); end private - # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#59 + # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#62 def autocorrect(corrector, to_h, map); end end @@ -38353,12 +38846,12 @@ class RuboCop::Cop::Style::MapToSet < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#34 def map_to_set?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#38 + # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#41 def on_send(node); end private - # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#52 + # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#55 def autocorrect(corrector, to_set, map); end end @@ -38372,21 +38865,19 @@ RuboCop::Cop::Style::MapToSet::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # method calls containing parameters. # # In the default style (require_parentheses), macro methods are allowed. -# Additional methods can be added to the `AllowedMethods` -# or `AllowedPatterns` list. These options are -# valid only in the default style. Macros can be included by -# either setting `IgnoreMacros` to false or adding specific macros to -# the `IncludedMacros` list. +# Additional methods can be added to the `AllowedMethods` or +# `AllowedPatterns` list. These options are valid only in the default +# style. Macros can be included by either setting `IgnoreMacros` to false +# or adding specific macros to the `IncludedMacros` list. # -# Precedence of options is all follows: +# Precedence of options is as follows: # # 1. `AllowedMethods` # 2. `AllowedPatterns` # 3. `IncludedMacros` # -# eg. If a method is listed in both -# `IncludedMacros` and `AllowedMethods`, then the latter takes -# precedence (that is, the method is allowed). +# If a method is listed in both `IncludedMacros` and `AllowedMethods`, +# then the latter takes precedence (that is, the method is allowed). # # In the alternative style (omit_parentheses), there are three additional # options. @@ -38405,14 +38896,29 @@ RuboCop::Cop::Style::MapToSet::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # to `true` allows the presence of parentheses in such a method call # even with arguments. # -# NOTE: Parentheses are still allowed in cases where omitting them -# results in ambiguous or syntactically incorrect code. For example, -# parentheses are required around a method with arguments when inside an -# endless method definition introduced in Ruby 3.0. Parentheses are also -# allowed when forwarding arguments with the triple-dot syntax introduced -# in Ruby 2.7 as omitting them starts an endless range. -# And Ruby 3.1's hash omission syntax has a case that requires parentheses -# because of the following issue: https://bugs.ruby-lang.org/issues/18396. +# NOTE: The style of `omit_parentheses` allows parentheses in cases where +# omitting them results in ambiguous or syntactically incorrect code. +# +# Non-exhaustive list of examples: +# +# - Parentheses are required allowed in method calls with arguments inside +# literals, logical operators, setting default values in position and +# keyword arguments, chaining and more. +# - Parentheses are allowed in method calls with arguments inside +# operators to avoid ambiguity. +# triple-dot syntax introduced in Ruby 2.7 as omitting them starts an +# endless range. +# - Parentheses are allowed when forwarding arguments with the +# triple-dot syntax introduced in Ruby 2.7 as omitting them starts an +# endless range. +# - Parentheses are required in calls with arguments when inside an +# endless method definition introduced in Ruby 3.0. +# - Ruby 3.1's hash omission syntax allows parentheses if the method call +# is in conditionals and requires parentheses if the call +# is not the value-returning expression. See +# https://bugs.ruby-lang.org/issues/18396. +# - Parentheses are required in anonymous arguments, keyword arguments +# and block passing in Ruby 3.2. # # @example AllowParenthesesInStringInterpolation: true # @@ -38430,34 +38936,28 @@ RuboCop::Cop::Style::MapToSet::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # array.delete e # # # bad -# foo.enforce(strict: true) +# action.enforce(strict: true) # # # good -# foo.enforce strict: true +# action.enforce strict: true # # # good -# # Allows parens for calls that won't produce valid Ruby or be ambiguous. -# model.validate strict(true) +# # Parentheses are allowed for code that can be ambiguous without +# # them. +# action.enforce(condition) || other_condition # # # good -# # Allows parens for calls that won't produce valid Ruby or be ambiguous. +# # Parentheses are allowed for calls that won't produce valid Ruby +# # without them. # yield path, File.basename(path) # # # good -# # Operators methods calls with parens -# array&.[](index) -# -# # good -# # Operators methods without parens, if you prefer -# array.[] index -# -# # good -# # Operators methods calls with parens -# array&.[](index) -# -# # good -# # Operators methods without parens, if you prefer -# array.[] index +# # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead +# # to ambiguous code. We allow them in conditionals and non-last +# # expressions. See https://bugs.ruby-lang.org/issues/18396 +# if meets(criteria:, action:) +# safe_action(action) || dangerous_action(action) +# end # @example IgnoreMacros: true (default) # # # good @@ -38547,7 +39047,7 @@ RuboCop::Cop::Style::MapToSet::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # # okay with `^assert` listed in `AllowedPatterns` # assert_equal 'test', x # -# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#195 +# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#202 class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::AllowedMethods @@ -38556,33 +39056,33 @@ class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#210 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 def on_csend(node); end - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#210 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 def on_send(node); end - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#210 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 def on_super(node); end - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#210 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 def on_yield(node); end private - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#219 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#226 def args_begin(node); end - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#228 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#235 def args_end(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#232 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#239 def args_parenthesized?(node); end class << self - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#206 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#213 def autocorrect_incompatible_with; end end end @@ -38595,37 +39095,37 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#74 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#70 def allowed_camel_case_method_call?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#163 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#158 def allowed_chained_call_with_parentheses?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#159 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#154 def allowed_multiline_call_with_parentheses?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#79 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#75 def allowed_string_interpolation_method_call?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#172 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#167 def ambiguous_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#201 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#196 def assigned_before?(node, target); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#209 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#204 def assignment_in_condition?(node); end # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#31 @@ -38633,60 +39133,52 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#146 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#141 def call_as_argument_or_chain?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#103 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#99 def call_in_literals?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#114 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#110 def call_in_logical_operators?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#123 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#119 def call_in_optional_arguments?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#127 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#123 def call_in_single_line_inheritance?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#131 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#127 def call_with_ambiguous_arguments?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#141 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#137 def call_with_braced_block?(node); end - # Require hash value omission be enclosed in parentheses to prevent the following issue: - # https://bugs.ruby-lang.org/issues/18396. - # - # @return [Boolean] - # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#62 - def exist_next_line_expression?(node); end - # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#219 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#214 def forwards_anonymous_rest_arguments?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#188 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#183 def hash_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#152 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#147 def hash_literal_in_arguments?(node); end # @return [Boolean] @@ -38696,23 +39188,26 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#205 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#200 def inside_string_interpolation?(node); end + # Require hash value omission be enclosed in parentheses to prevent the following issue: + # https://bugs.ruby-lang.org/issues/18396. + # # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#91 - def legitimate_call_with_parentheses?(node); end + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#58 + def last_expression?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#184 - def logical_operator?(node); end + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#87 + def legitimate_call_with_parentheses?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#56 - def modifier_form?(node); end + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#179 + def logical_operator?(node); end # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#40 def offense_range(node); end @@ -38722,12 +39217,12 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#84 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#80 def parentheses_at_the_end_of_multiline_call?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#192 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#187 def regexp_slash_literal?(node); end # @return [Boolean] @@ -38737,27 +39232,27 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#176 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#171 def splat?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#70 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#66 def super_call_without_arguments?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#66 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#62 def syntax_like_method_call?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#180 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#175 def ternary_if?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#196 + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#191 def unary_literal?(node); end end @@ -39840,33 +40335,33 @@ class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#57 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#60 def arguments_range(node); end - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#38 - def autocorrect(corrector, node); end + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#41 + def autocorrect(corrector, node, begin_of_arguments); end - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#69 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#72 def closing_line(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#73 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#76 def correction_exceeds_max_line_length?(node); end - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#81 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#84 def definition_width(node); end - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#77 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#80 def indentation_width(node); end - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#53 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#56 def last_line_source_of_arguments(arguments); end - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#85 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#88 def max_line_length; end - # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#65 + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#68 def opening_line(node); end end @@ -40033,70 +40528,79 @@ RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String) # # # good # foo if [b.lightweight, b.heavyweight].include?(a) +# @example ComparisonsThreshold: 2 (default) +# # bad +# foo if a == 'a' || a == 'b' +# @example ComparisonsThreshold: 3 +# # good +# foo if a == 'a' || a == 'b' # -# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#43 +# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#52 class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#49 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#58 def on_new_investigation; end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#53 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#62 def on_or(node); end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#78 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#88 def simple_comparison_lhs?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#83 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#93 def simple_comparison_rhs?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#75 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#85 def simple_double_comparison?(param0 = T.unsafe(nil)); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#151 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#161 def allow_method_comparison?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#126 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#136 def comparison?(node); end + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#165 + def comparisons_threshold; end + # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#118 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#128 def nested_comparison?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#87 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#97 def nested_variable_comparison?(node); end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#146 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#156 def reset_comparison; end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#130 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#140 def root_of_or_node(or_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#140 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#150 def switch_comparison?(node); end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#114 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#124 def variable_name(node); end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#93 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#103 def variables_in_node(node); end - # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#101 + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#111 def variables_in_simple_node(node); end end -# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#46 +# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#55 RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) # Checks whether some constant value isn't a @@ -40168,13 +40672,16 @@ RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) # # shareable_constant_value: literal # CONST = [1, 2, 3] # -# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#87 +# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#83 class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue include ::RuboCop::Cop::FrozenStringLiteral include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector + # source://rubocop-sorbet/0.7.0/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#15 + def on_assignment(value); end + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#127 def on_casgn(node); end @@ -40190,6 +40697,9 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#217 def splat_value(param0 = T.unsafe(nil)); end + # source://rubocop-sorbet/0.7.0/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#10 + def t_let(param0 = T.unsafe(nil)); end + private # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#169 @@ -40216,9 +40726,6 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#184 def mutable_literal?(value); end - # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#141 - def on_assignment(value); end - # @return [Boolean] # # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#204 @@ -41977,7 +42484,7 @@ class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Base include ::RuboCop::Cop::RescueNode extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#115 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#124 def implicit_self_getter?(param0 = T.unsafe(nil)); end # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#31 @@ -41989,55 +42496,55 @@ class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Base # This makes the sorting algorithm work for expressions such as # `self.a, self.b = b, a`. # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#108 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#117 def add_self_to_getters(right_elements); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#60 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#64 def allowed_lhs?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#54 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#58 def allowed_masign?(lhs_elements, rhs_elements); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#68 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#72 def allowed_rhs?(node); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#80 - def assignment_corrector(node, order); end + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#84 + def assignment_corrector(node, rhs, order); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#44 - def autocorrect(corrector, node); end + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#49 + def autocorrect(corrector, node, lhs, rhs); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#91 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#100 def find_valid_order(left_elements, right_elements); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#174 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#183 def modifier_statement?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#76 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#80 def return_of_method_call?(node); end end # Helper class necessitated by silly design of TSort prior to Ruby 2.1 # Newer versions have a better API, but that doesn't help us # -# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#119 +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#128 class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter include ::TSort extend ::RuboCop::AST::NodePattern::Macros # @return [AssignmentSorter] a new instance of AssignmentSorter # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#132 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#141 def initialize(assignments); end # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`. @@ -42045,71 +42552,81 @@ class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter # # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#161 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#170 def accesses?(rhs, lhs); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#154 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#163 def dependency?(lhs, rhs); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#130 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#139 def matching_calls(param0, param1, param2); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#140 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#149 def tsort_each_child(assignment); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#136 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#145 def tsort_each_node(&block); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#127 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#136 def uses_var?(param0, param1); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#124 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#133 def var_name(param0 = T.unsafe(nil)); end end # An internal class for correcting parallel assignment # -# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#181 +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#190 class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector include ::RuboCop::Cop::Alignment # @return [GenericCorrector] a new instance of GenericCorrector # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#186 - def initialize(node, config, new_elements); end + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#195 + def initialize(node, rhs, modifier, config, new_elements); end # Returns the value of attribute config. # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#184 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 def config; end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#192 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#203 def correction; end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#196 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#207 def correction_range; end # Returns the value of attribute node. # - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#184 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 def node; end + # Returns the value of attribute rescue_result. + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 + def rescue_result; end + + # Returns the value of attribute rhs. + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 + def rhs; end + protected - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#202 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#213 def assignment; end private - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#222 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#233 def cop_config; end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#218 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#229 def extract_sources(node); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#208 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#219 def source(node); end end @@ -42119,37 +42636,37 @@ RuboCop::Cop::Style::ParallelAssignment::MSG = T.let(T.unsafe(nil), String) # An internal class for correcting parallel assignment # guarded by if, unless, while, or until # -# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#267 +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#275 class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#268 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#276 def correction; end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#277 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#285 def correction_range; end private - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#283 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#291 def modifier_range(node); end end # An internal class for correcting parallel assignment # protected by rescue # -# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#229 +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#240 class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#230 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#241 def correction; end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#244 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#252 def correction_range; end private - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#255 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#263 def begin_correction(rescue_result); end - # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#250 + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#258 def def_correction(rescue_result); end end @@ -42309,7 +42826,7 @@ class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#86 def include_same_character_as_used_for_delimiter?(node, type); end - # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#108 + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#107 def matchpairs(begin_delimiter); end # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#67 @@ -42321,7 +42838,7 @@ class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#74 def preferred_delimiters_for(type); end - # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#100 + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#99 def string_source(node); end # @return [Boolean] @@ -42849,6 +43366,47 @@ end # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#57 RuboCop::Cop::Style::RedundantArgument::MSG = T.let(T.unsafe(nil), String) +# Checks for the instantiation of array using redundant `Array` constructor. +# Autocorrect replaces to array literal which is the simplest and fastest. +# +# @example +# +# # bad +# Array.new([]) +# Array[] +# Array([]) +# Array.new(['foo', 'foo', 'foo']) +# Array['foo', 'foo', 'foo'] +# Array(['foo', 'foo', 'foo']) +# +# # good +# [] +# ['foo', 'foo', 'foo'] +# Array.new(3, 'foo') +# Array.new(3) { 'foo' } +# +# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#25 +class RuboCop::Cop::Style::RedundantArrayConstructor < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#47 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#33 + def redundant_array_constructor(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#69 + def register_offense(range, node, replacement); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#28 +RuboCop::Cop::Style::RedundantArrayConstructor::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#30 +RuboCop::Cop::Style::RedundantArrayConstructor::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Checks for redundant assignment before returning. # # @example @@ -43386,6 +43944,31 @@ end # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#46 RuboCop::Cop::Style::RedundantConstantBase::MSG = T.let(T.unsafe(nil), String) +# Checks for uses a redundant current directory in path. +# +# @example +# +# # bad +# require_relative './path/to/feature' +# +# # good +# require_relative 'path/to/feature' +# +# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#16 +class RuboCop::Cop::Style::RedundantCurrentDirectoryInPath < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#23 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#21 +RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::CURRENT_DIRECTORY_PATH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#20 +RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::MSG = T.let(T.unsafe(nil), String) + # Checks for redundant uses of double splat hash braces. # # @example @@ -43519,11 +44102,12 @@ RuboCop::Cop::Style::RedundantException::MSG_2 = T.let(T.unsafe(nil), String) # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#25 RuboCop::Cop::Style::RedundantException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# Identifies places where `fetch(key) { value }` -# can be replaced by `fetch(key, value)`. +# Identifies places where `fetch(key) { value }` can be replaced by `fetch(key, value)`. +# +# In such cases `fetch(key, value)` method is faster than `fetch(key) { value }`. # -# In such cases `fetch(key, value)` method is faster -# than `fetch(key) { value }`. +# NOTE: The block string `'value'` in `hash.fetch(:key) { 'value' }` is detected +# but not when disabled. # # @example SafeForConstants: false (default) # # bad @@ -43546,59 +44130,59 @@ RuboCop::Cop::Style::RedundantException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), # # good # ENV.fetch(:key, VALUE) # -# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#38 +# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#40 class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base include ::RuboCop::Cop::FrozenStringLiteral include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#53 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#55 def on_block(node); end - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#87 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#89 def rails_cache?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#46 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#48 def redundant_fetch_block_candidate?(param0 = T.unsafe(nil)); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#72 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#74 def basic_literal?(node); end - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#102 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#104 def build_bad_method(send, body); end - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#95 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#97 def build_good_method(send, body); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#109 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#111 def check_for_constant?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#113 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#115 def check_for_string?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#76 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#78 def const_type?(node); end - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#91 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#93 def fetch_range(send, node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#80 + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#82 def should_not_check?(send, body); end end -# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#43 +# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#45 RuboCop::Cop::Style::RedundantFetchBlock::MSG = T.let(T.unsafe(nil), String) # Checks for the presence of superfluous `.rb` extension in @@ -43645,6 +44229,70 @@ RuboCop::Cop::Style::RedundantFileExtensionInRequire::MSG = T.let(T.unsafe(nil), # source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#32 RuboCop::Cop::Style::RedundantFileExtensionInRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Identifies usages of `any?`, `empty?` or `none?` predicate methods +# chained to `select`/`filter`/`find_all` and change them to use predicate method instead. +# +# @example +# # bad +# arr.select { |x| x > 1 }.any? +# +# # good +# arr.any? { |x| x > 1 } +# +# # bad +# arr.select { |x| x > 1 }.empty? +# arr.select { |x| x > 1 }.none? +# +# # good +# arr.none? { |x| x > 1 } +# +# # good +# relation.select(:name).any? +# arr.select { |x| x > 1 }.any?(&:odd?) +# @example AllCops:ActiveSupportExtensionsEnabled: false (default) +# # good +# arr.select { |x| x > 1 }.many? +# @example AllCops:ActiveSupportExtensionsEnabled: true +# # bad +# arr.select { |x| x > 1 }.many? +# +# # good +# arr.many? { |x| x > 1 } +# +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#38 +class RuboCop::Cop::Style::RedundantFilterChain < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#65 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#47 + def select_predicate?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#91 + def offense_range(select_node, predicate_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#95 + def predicate_range(predicate_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#77 + def register_offense(select_node, predicate_node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#41 +RuboCop::Cop::Style::RedundantFilterChain::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#43 +RuboCop::Cop::Style::RedundantFilterChain::RAILS_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#56 +RuboCop::Cop::Style::RedundantFilterChain::REPLACEMENT_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#44 +RuboCop::Cop::Style::RedundantFilterChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Check for uses of `Object#freeze` on immutable objects. # # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0. @@ -43938,6 +44586,156 @@ end # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#43 RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String) +# Check for redundant line continuation. +# +# This cop marks a line continuation as redundant if removing the backslash +# does not result in a syntax error. +# However, a backslash at the end of a comment or +# for string concatenation is not redundant and is not considered an offense. +# +# @example +# # bad +# foo. \ +# bar +# foo \ +# &.bar \ +# .baz +# +# # good +# foo. +# bar +# foo +# &.bar +# .baz +# +# # bad +# [foo, \ +# bar] +# {foo: \ +# bar} +# +# # good +# [foo, +# bar] +# {foo: +# bar} +# +# # bad +# foo(bar, \ +# baz) +# +# # good +# foo(bar, +# baz) +# +# # also good - backslash in string concatenation is not redundant +# foo('bar' \ +# 'baz') +# +# # also good - backslash at the end of a comment is not redundant +# foo(bar, # \ +# baz) +# +# # also good - backslash at the line following the newline begins with a + or -, +# # it is not redundant +# 1 \ +# + 2 \ +# - 3 +# +# # also good - backslash with newline between the method name and its arguments, +# # it is not redundant. +# some_method \ +# (argument) +# +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#67 +class RuboCop::Cop::Style::RedundantLineContinuation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#78 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#166 + def argument_is_method?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#134 + def argument_newline?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#100 + def ends_with_backslash_without_comment?(source_line); end + + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#146 + def find_node_for_line(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#122 + def inside_string_literal?(range, token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#108 + def inside_string_literal_or_method_with_argument?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#173 + def method_call_with_arguments?(node); end + + # A method call without parentheses such as the following cannot remove `\`: + # + # do_something \ + # argument + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#130 + def method_with_argument?(current_token, next_token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#114 + def redundant_line_continuation?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#93 + def require_line_continuation?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#152 + def same_line?(node, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#177 + def start_with_arithmetic_operator?(source_line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#104 + def string_concatenation?(source_line); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#72 +RuboCop::Cop::Style::RedundantLineContinuation::ALLOWED_STRING_TOKENS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#73 +RuboCop::Cop::Style::RedundantLineContinuation::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#71 +RuboCop::Cop::Style::RedundantLineContinuation::MSG = T.let(T.unsafe(nil), String) + # Checks for redundant parentheses. # # @example @@ -44196,6 +44994,72 @@ RuboCop::Cop::Style::RedundantPercentQ::SINGLE_QUOTE = T.let(T.unsafe(nil), Stri # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#31 RuboCop::Cop::Style::RedundantPercentQ::STRING_INTERPOLATION_REGEXP = T.let(T.unsafe(nil), Regexp) +# Identifies places where argument can be replaced from +# a deterministic regexp to a string. +# +# @example +# # bad +# 'foo'.byteindex(/f/) +# 'foo'.byterindex(/f/) +# 'foo'.gsub(/f/, 'x') +# 'foo'.gsub!(/f/, 'x') +# 'foo'.partition(/f/) +# 'foo'.rpartition(/f/) +# 'foo'.scan(/f/) +# 'foo'.split(/f/) +# 'foo'.start_with?(/f/) +# 'foo'.sub(/f/, 'x') +# 'foo'.sub!(/f/, 'x') +# +# # good +# 'foo'.byteindex('f') +# 'foo'.byterindex('f') +# 'foo'.gsub('f', 'x') +# 'foo'.gsub!('f', 'x') +# 'foo'.partition('f') +# 'foo'.rpartition('f') +# 'foo'.scan('f') +# 'foo'.split('f') +# 'foo'.start_with?('f') +# 'foo'.sub('f', 'x') +# 'foo'.sub!('f', 'x') +# +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#35 +class RuboCop::Cop::Style::RedundantRegexpArgument < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#47 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#47 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#64 + def determinist_regexp?(regexp_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#68 + def preferred_argument(regexp_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#81 + def replacement(regexp_node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#42 +RuboCop::Cop::Style::RedundantRegexpArgument::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#38 +RuboCop::Cop::Style::RedundantRegexpArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#39 +RuboCop::Cop::Style::RedundantRegexpArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#43 +RuboCop::Cop::Style::RedundantRegexpArgument::STR_SPECIAL_CHARS = T.let(T.unsafe(nil), Array) + # Checks for unnecessary single-element Regexp character classes. # # @example @@ -44244,7 +45108,7 @@ class RuboCop::Cop::Style::RedundantRegexpCharacterClass < ::RuboCop::Cop::Base # @return [Boolean] # # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#83 - def multiple_codepoins?(expression); end + def multiple_codepoints?(expression); end # @return [Boolean] # @@ -44276,6 +45140,37 @@ RuboCop::Cop::Style::RedundantRegexpCharacterClass::MSG_REDUNDANT_CHARACTER_CLAS # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#33 RuboCop::Cop::Style::RedundantRegexpCharacterClass::REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = T.let(T.unsafe(nil), Array) +# Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`. +# Autocorrect replaces to regexp literal which is the simplest and fastest. +# +# @example +# +# # bad +# Regexp.new(/regexp/) +# Regexp.compile(/regexp/) +# +# # good +# /regexp/ +# Regexp.new('regexp') +# Regexp.compile('regexp') +# +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#20 +class RuboCop::Cop::Style::RedundantRegexpConstructor < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#33 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#27 + def redundant_regexp_constructor(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#23 +RuboCop::Cop::Style::RedundantRegexpConstructor::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#24 +RuboCop::Cop::Style::RedundantRegexpConstructor::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Checks for redundant escapes inside Regexp literals. # # @example @@ -44318,26 +45213,26 @@ class RuboCop::Cop::Style::RedundantRegexpEscape < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#59 + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#60 def allowed_escape?(node, char, index, within_character_class); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#75 + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#76 def char_class_begins_or_ends_with_escaped_hyphen?(node, index); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#91 + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#92 def delimiter?(node, char); end # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped. - # It's for compatibility with regexp_arser 1.8 and will never be maintained. + # It's for compatibility with regexp_parser 1.8 and will never be maintained. # - # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#98 + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#99 def each_escape(node); end - # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#125 + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#126 def escape_range_at_index(node, index); end end @@ -44732,12 +45627,12 @@ class RuboCop::Cop::Style::RedundantSelfAssignmentBranch < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#64 def multiple_statements?(branch); end - # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#72 + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#74 def register_offense(if_node, offense_branch, opposite_branch, keyword); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#68 + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#70 def self_assign?(variable, branch); end # @return [Boolean] @@ -44939,92 +45834,101 @@ class RuboCop::Cop::Style::RedundantStringEscape < ::RuboCop::Cop::Base include ::RuboCop::Cop::MatchRange extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#44 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#43 def on_str(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#80 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#79 def allowed_escape?(node, range); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#120 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#119 def array_literal?(node, prefix); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#74 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#73 def begin_loc_present?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#154 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#153 def delimiter?(node, char); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#170 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#171 def disabling_interpolation?(range); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#150 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#149 def heredoc?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#140 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#139 def heredoc_with_disabled_interpolation?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#101 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#100 def interpolation_not_enabled?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#166 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#167 def literal_in_interpolated_or_multiline_string?(node); end - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#60 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#59 def message(range); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#136 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#135 def percent_array_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#112 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#111 def percent_q_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#128 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#127 def percent_w_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#132 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#131 def percent_w_upper_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#108 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#107 def single_quoted?(node); end - # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#64 + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#63 def str_contents_range(node); end end -# source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#42 +# source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#41 RuboCop::Cop::Style::RedundantStringEscape::MSG = T.let(T.unsafe(nil), String) -# Enforces using // or %r around regular expressions. +# Enforces using `//` or `%r` around regular expressions. +# +# NOTE: The following `%r` cases using a regexp starts with a blank or `=` +# as a method argument allowed to prevent syntax errors. +# +# [source,ruby] +# ---- +# do_something %r{ regexp} # `do_something / regexp/` is an invalid syntax. +# do_something %r{=regexp} # `do_something /=regexp/` is an invalid syntax. +# ---- # # @example EnforcedStyle: slashes (default) # # bad @@ -45099,94 +46003,94 @@ RuboCop::Cop::Style::RedundantStringEscape::MSG = T.let(T.unsafe(nil), String) # # good # x =~ /home\// # -# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#84 +# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#93 class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#92 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#101 def on_regexp(node); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#135 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#144 def allow_inner_slashes?; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#123 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#132 def allowed_mixed_percent_r?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#113 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#122 def allowed_mixed_slash?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#152 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#161 def allowed_omit_parentheses_with_percent_r_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#117 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#126 def allowed_percent_r_literal?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#109 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#118 def allowed_slash_literal?(node); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#212 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#221 def calculate_replacement(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#127 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#136 def contains_disallowed_slash?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#131 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#140 def contains_slash?(node); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#161 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#170 def correct_delimiters(node, corrector); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#167 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#176 def correct_inner_slashes(node, corrector); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#200 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#209 def inner_slash_after_correction(node); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#196 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#205 def inner_slash_before_correction(node); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#204 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#213 def inner_slash_for(opening_delimiter); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#183 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#192 def inner_slash_indices(node); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#139 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#148 def node_body(node, include_begin_nodes: T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#148 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#157 def preferred_delimiters; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#144 + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#153 def slash_literal?(node); end end -# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#90 +# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#99 RuboCop::Cop::Style::RegexpLiteral::MSG_USE_PERCENT_R = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#89 +# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#98 RuboCop::Cop::Style::RegexpLiteral::MSG_USE_SLASHES = T.let(T.unsafe(nil), String) # Sort `require` and `require_relative` in alphabetical order. @@ -45259,23 +46163,26 @@ class RuboCop::Cop::Style::RequireOrder < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/style/require_order.rb#104 + # source://rubocop//lib/rubocop/cop/style/require_order.rb#115 + def autocorrect(corrector, node, previous_older_sibling); end + + # source://rubocop//lib/rubocop/cop/style/require_order.rb#101 def find_previous_older_sibling(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/require_order.rb#127 + # source://rubocop//lib/rubocop/cop/style/require_order.rb#133 def in_same_section?(node1, node2); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/require_order.rb#100 + # source://rubocop//lib/rubocop/cop/style/require_order.rb#97 def not_modifier_form?(node); end - # source://rubocop//lib/rubocop/cop/style/require_order.rb#117 + # source://rubocop//lib/rubocop/cop/style/require_order.rb#123 def search_node(node); end - # source://rubocop//lib/rubocop/cop/style/require_order.rb#121 + # source://rubocop//lib/rubocop/cop/style/require_order.rb#127 def sibling_node(node); end end @@ -45285,9 +46192,7 @@ RuboCop::Cop::Style::RequireOrder::MSG = T.let(T.unsafe(nil), String) # source://rubocop//lib/rubocop/cop/style/require_order.rb#71 RuboCop::Cop::Style::RequireOrder::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# Checks for uses of rescue in its modifier form. -# -# The cop to check `rescue` in its modifier form is added for following +# Checks for uses of `rescue` in its modifier form is added for following # reasons: # # * The syntax of modifier form `rescue` can be misleading because it @@ -45322,36 +46227,36 @@ RuboCop::Cop::Style::RequireOrder::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array # handle_error # end # -# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#42 +# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#40 class RuboCop::Cop::Style::RescueModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::RescueNode extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#54 + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#52 def on_resbody(node); end private - # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#72 + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#70 def correct_rescue_block(corrector, node, parenthesized); end - # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#88 + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#86 def indentation_and_offset(node, parenthesized); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#68 + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#66 def parenthesized?(node); end class << self - # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#50 + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#48 def autocorrect_incompatible_with; end end end -# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#48 +# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#46 RuboCop::Cop::Style::RescueModifier::MSG = T.let(T.unsafe(nil), String) # Checks for rescuing `StandardError`. There are two supported @@ -45519,6 +46424,63 @@ RuboCop::Cop::Style::ReturnNil::RETURN_MSG = T.let(T.unsafe(nil), String) # source://rubocop//lib/rubocop/cop/style/return_nil.rb#36 RuboCop::Cop::Style::ReturnNil::RETURN_NIL_MSG = T.let(T.unsafe(nil), String) +# Checks if `return` or `return nil` is used in predicate method definitions. +# +# @example +# # bad +# def foo? +# return if condition +# +# do_something? +# end +# +# # bad +# def foo? +# return nil if condition +# +# do_something? +# end +# +# # good +# def foo? +# return false if condition +# +# do_something? +# end +# @example AllowedMethod: ['foo?'] +# # good +# def foo? +# return if condition +# +# do_something? +# end +# @example AllowedPattern: [/foo/] +# # good +# def foo? +# return if condition +# +# do_something? +# end +# +# source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#50 +class RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#62 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#62 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#58 + def return_nil?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#55 +RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition::MSG = T.let(T.unsafe(nil), String) + # Transforms usages of a method call safeguarded by a non `nil` # check for the variable whose method is being called to # safe navigation (`&.`). If there is a method chain, all of the methods @@ -45826,7 +46788,7 @@ class RuboCop::Cop::Style::SelectByRegexp < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#74 def env_const?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#87 + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#88 def on_send(node); end # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#56 @@ -45834,29 +46796,32 @@ class RuboCop::Cop::Style::SelectByRegexp < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#122 + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#132 def extract_send_node(block_node); end - # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#135 + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#145 def find_regexp(node, block); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#146 + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#156 def match_predicate_without_receiver?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#131 + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#141 def opposite?(regexp_method_send_node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#102 + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#106 def receiver_allowed?(node); end - # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#108 - def register_offense(node, block_node, regexp, opposite); end + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#120 + def register_offense(node, block_node, regexp, replacement); end + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#112 + def replacement(regexp_method_send_node, node); end end # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#49 @@ -45975,27 +46940,37 @@ class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/semicolon.rb#102 + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#105 def exist_semicolon_after_left_curly_brace?(tokens); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/semicolon.rb#98 + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#113 + def exist_semicolon_after_left_string_interpolation_brace?(tokens); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#101 def exist_semicolon_before_right_curly_brace?(tokens); end - # source://rubocop//lib/rubocop/cop/style/semicolon.rb#126 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#109 + def exist_semicolon_before_right_string_interpolation_brace?(tokens); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#137 def expressions_per_line(exprs); end - # source://rubocop//lib/rubocop/cop/style/semicolon.rb#140 + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#151 def find_range_node(token_before_semicolon); end - # source://rubocop//lib/rubocop/cop/style/semicolon.rb#132 + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#143 def find_semicolon_positions(line); end - # source://rubocop//lib/rubocop/cop/style/semicolon.rb#146 + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#157 def range_nodes; end - # source://rubocop//lib/rubocop/cop/style/semicolon.rb#106 + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#117 def register_semicolon(line, column, after_expression, token_before_semicolon = T.unsafe(nil)); end # source://rubocop//lib/rubocop/cop/style/semicolon.rb#86 @@ -46474,10 +47449,10 @@ class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#238 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#240 def allow_modifier?; end - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#223 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#225 def arguments_range(node); end # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#81 @@ -46510,10 +47485,10 @@ class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#182 def correct_outer_condition(corrector, condition); end - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#193 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#195 def insert_bang(corrector, node, is_modify_form); end - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#206 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#208 def insert_bang_for_and(corrector, node); end # @return [Boolean] @@ -46523,15 +47498,15 @@ class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#242 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#244 def outer_condition_modify_form?(node, if_branch); end - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#234 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#236 def replace_condition(condition); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#218 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#220 def require_parentheses?(condition); end # @return [Boolean] @@ -46544,7 +47519,7 @@ class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#229 + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#231 def wrap_condition?(node); end class << self @@ -46556,7 +47531,7 @@ end # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#53 RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String) -# This cop looks for uses of Perl-style global variables. +# Looks for uses of Perl-style global variables. # Correcting to global variables in the 'English' library # will add a require statement to the top of the file if # enabled by RequireEnglish config. @@ -46631,88 +47606,88 @@ RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String) # puts $* # @example EnforcedStyle: use_builtin_english_names # -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#88 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#87 class RuboCop::Cop::Style::SpecialGlobalVars < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::RequireLibrary extend ::RuboCop::Cop::AutoCorrector - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#177 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#176 def autocorrect(corrector, node, global_var); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#169 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#168 def message(global_var); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#153 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#152 def on_gvar(node); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#148 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#147 def on_new_investigation; end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#248 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#247 def add_require_english?; end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#242 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#241 def english_name_replacement(preferred_name, node); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#191 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#190 def format_english_message(global_var); end # For now, we assume that lists are 2 items or less. Easy grammar! # - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#213 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#212 def format_list(items); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#199 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#198 def format_message(english, regular, global); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#236 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#235 def matching_styles(global); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#228 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#227 def preferred_names(global); end - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#217 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#216 def replacement(node, global_var); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#252 + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#251 def should_require_english?(global_var); end end -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#129 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#128 RuboCop::Cop::Style::SpecialGlobalVars::BUILTIN_VARS = T.let(T.unsafe(nil), Hash) -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#101 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#100 RuboCop::Cop::Style::SpecialGlobalVars::ENGLISH_VARS = T.let(T.unsafe(nil), Hash) -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#146 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#145 RuboCop::Cop::Style::SpecialGlobalVars::LIBRARY_NAME = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#94 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#93 RuboCop::Cop::Style::SpecialGlobalVars::MSG_BOTH = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#97 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#96 RuboCop::Cop::Style::SpecialGlobalVars::MSG_ENGLISH = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#99 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#98 RuboCop::Cop::Style::SpecialGlobalVars::MSG_REGULAR = T.let(T.unsafe(nil), String) # Anything *not* in this set is provided by the English library. # -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#123 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#122 RuboCop::Cop::Style::SpecialGlobalVars::NON_ENGLISH_VARS = T.let(T.unsafe(nil), Set) -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#125 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#124 RuboCop::Cop::Style::SpecialGlobalVars::PERL_VARS = T.let(T.unsafe(nil), Hash) -# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#140 +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#139 RuboCop::Cop::Style::SpecialGlobalVars::STYLE_VARS_MAP = T.let(T.unsafe(nil), Hash) # Check for parentheses around stabby lambda arguments. @@ -47587,38 +48562,38 @@ RuboCop::Cop::Style::SymbolProc::SUPER_TYPES = T.let(T.unsafe(nil), Array) # Corrector to correct conditional assignment in ternary conditions. # -# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#498 +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#500 class RuboCop::Cop::Style::TernaryCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#503 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#505 def correct(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#507 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#509 def move_assignment_inside_condition(corrector, node); end private - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#521 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#523 def correction(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#534 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#536 def element_assignment?(node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#538 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#540 def extract_branches(node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#551 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#553 def move_branch_inside_condition(corrector, branch, assignment); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#546 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#548 def remove_parentheses(corrector, node); end - # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#525 + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#527 def ternary(node); end end end @@ -47878,6 +48853,9 @@ class RuboCop::Cop::Style::TrailingBodyOnClass < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#25 def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#25 + def on_sclass(node); end end # source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#23 @@ -48666,6 +49644,7 @@ RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String) # to read and understand. # # This cop supports two styles: +# # - `forbid_mixed_logical_operators` (default) # - `forbid_logical_operators` # @@ -48704,44 +49683,44 @@ RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String) # return unless a # return unless a? # -# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#49 +# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#50 class RuboCop::Cop::Style::UnlessLogicalOperators < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle - # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#61 + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#62 def and_with_or?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#66 + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#67 def logical_operator?(param0 = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#70 + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#71 def on_if(node); end - # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#56 + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#57 def or_with_and?(param0 = T.unsafe(nil)); end private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#82 + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#83 def mixed_logical_operator?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#89 + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#90 def mixed_precedence_and?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#96 + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#97 def mixed_precedence_or?(node); end end -# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#53 +# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#54 RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String) -# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#52 +# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#53 RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_MIXED_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String) # Checks for accessing the first element of `String#unpack` @@ -49053,6 +50032,49 @@ RuboCop::Cop::Style::WordArray::ARRAY_MSG = T.let(T.unsafe(nil), String) # source://rubocop//lib/rubocop/cop/style/word_array.rb#78 RuboCop::Cop::Style::WordArray::PERCENT_MSG = T.let(T.unsafe(nil), String) +# Checks for the use of `YAML.load`, `YAML.safe_load`, and `YAML.parse` with +# `File.read` argument. +# +# NOTE: `YAML.safe_load_file` was introduced in Ruby 3.0. +# +# @example +# +# # bad +# YAML.load(File.read(path)) +# YAML.parse(File.read(path)) +# +# # good +# YAML.load_file(path) +# YAML.parse_file(path) +# +# # bad +# YAML.safe_load(File.read(path)) # Ruby 3.0 and newer +# +# # good +# YAML.safe_load_file(path) # Ruby 3.0 and newer +# +# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#27 +class RuboCop::Cop::Style::YAMLFileRead < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#41 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#34 + def yaml_file_read?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#60 + def offense_range(node); end +end + +# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#30 +RuboCop::Cop::Style::YAMLFileRead::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#31 +RuboCop::Cop::Style::YAMLFileRead::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Enforces or forbids Yoda conditions, # i.e. comparison operations where the order of expression is reversed. # eg. `5 == x` @@ -49116,15 +50138,15 @@ class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base private - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#147 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#149 def actual_code_range(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#143 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#145 def constant_portion?(node); end - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#136 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#138 def corrected_code(node); end # @return [Boolean] @@ -49139,38 +50161,38 @@ class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#171 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#173 def interpolation?(node); end - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#132 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#134 def message(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#155 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#157 def non_equality_operator?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#159 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#161 def noncommutative_operator?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#167 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#169 def program_name?(name); end - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#151 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#153 def reverse_comparison(operator); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#163 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#165 def source_file_path_constant?(node); end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#121 + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#122 def valid_yoda?(node); end # @return [Boolean] @@ -50151,6 +51173,54 @@ RuboCop::Cop::Utils::FormatString::TYPE = T.let(T.unsafe(nil), Regexp) # source://rubocop//lib/rubocop/cop/utils/format_string.rb#12 RuboCop::Cop::Utils::FormatString::WIDTH = T.let(T.unsafe(nil), Regexp) +# Helper to abstract complexity of building range pairs +# with octal escape reconstruction (needed for regexp_parser < 2.7). +# +# source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#8 +class RuboCop::Cop::Utils::RegexpRanges + # @return [RegexpRanges] a new instance of RegexpRanges + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#11 + def initialize(root); end + + # Returns the value of attribute compound_token. + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#9 + def compound_token; end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#16 + def pairs; end + + # Returns the value of attribute root. + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#9 + def root; end + + private + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#65 + def compose_range(expressions, current); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#77 + def escaped_octal?(expr); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#81 + def octal_digit?(char); end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#85 + def pop_octal_digits(expressions); end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#31 + def populate(expr); end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#50 + def process_set(expressions, current); end +end + # This force provides a way to track local variables and scopes of Ruby. # Cops interact with this force need to override some of the hook methods. # @@ -50180,59 +51250,59 @@ class RuboCop::Cop::VariableForce < ::RuboCop::Cop::Force # # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#75 + # source://rubocop//lib/rubocop/cop/variable_force.rb#76 def investigate(processed_source); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#84 + # source://rubocop//lib/rubocop/cop/variable_force.rb#85 def process_node(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#70 + # source://rubocop//lib/rubocop/cop/variable_force.rb#71 def variable_table; end private - # source://rubocop//lib/rubocop/cop/variable_force.rb#367 + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 def after_declaring_variable(arg); end - # source://rubocop//lib/rubocop/cop/variable_force.rb#367 + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 def after_entering_scope(arg); end - # source://rubocop//lib/rubocop/cop/variable_force.rb#367 + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 def after_leaving_scope(arg); end - # source://rubocop//lib/rubocop/cop/variable_force.rb#367 + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 def before_declaring_variable(arg); end - # source://rubocop//lib/rubocop/cop/variable_force.rb#367 + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 def before_entering_scope(arg); end - # source://rubocop//lib/rubocop/cop/variable_force.rb#367 + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 def before_leaving_scope(arg); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#338 + # source://rubocop//lib/rubocop/cop/variable_force.rb#339 def descendant_reference(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#328 + # source://rubocop//lib/rubocop/cop/variable_force.rb#329 def each_descendant_reference(loop_node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#313 + # source://rubocop//lib/rubocop/cop/variable_force.rb#314 def find_variables_in_loop(loop_node); end # This is called for each scope recursively. # # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#93 + # source://rubocop//lib/rubocop/cop/variable_force.rb#94 def inspect_variables_in_scope(scope_node); end # Mark all assignments which are referenced in the same loop @@ -50241,98 +51311,98 @@ class RuboCop::Cop::VariableForce < ::RuboCop::Cop::Force # # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#294 + # source://rubocop//lib/rubocop/cop/variable_force.rb#295 def mark_assignments_as_referenced_in_loop(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#125 + # source://rubocop//lib/rubocop/cop/variable_force.rb#126 def node_handler_method_name(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#99 + # source://rubocop//lib/rubocop/cop/variable_force.rb#100 def process_children(origin_node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#230 + # source://rubocop//lib/rubocop/cop/variable_force.rb#231 def process_loop(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#159 + # source://rubocop//lib/rubocop/cop/variable_force.rb#160 def process_regexp_named_captures(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#245 + # source://rubocop//lib/rubocop/cop/variable_force.rb#246 def process_rescue(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#264 + # source://rubocop//lib/rubocop/cop/variable_force.rb#265 def process_scope(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#283 + # source://rubocop//lib/rubocop/cop/variable_force.rb#284 def process_send(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#141 + # source://rubocop//lib/rubocop/cop/variable_force.rb#142 def process_variable_assignment(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#129 + # source://rubocop//lib/rubocop/cop/variable_force.rb#130 def process_variable_declaration(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#218 + # source://rubocop//lib/rubocop/cop/variable_force.rb#219 def process_variable_multiple_assignment(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#183 + # source://rubocop//lib/rubocop/cop/variable_force.rb#184 def process_variable_operator_assignment(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#225 + # source://rubocop//lib/rubocop/cop/variable_force.rb#226 def process_variable_referencing(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#256 + # source://rubocop//lib/rubocop/cop/variable_force.rb#257 def process_zero_arity_super(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#177 + # source://rubocop//lib/rubocop/cop/variable_force.rb#178 def regexp_captured_names(node); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/variable_force.rb#350 + # source://rubocop//lib/rubocop/cop/variable_force.rb#351 def scanned_node?(node); end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#354 + # source://rubocop//lib/rubocop/cop/variable_force.rb#355 def scanned_nodes; end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#107 + # source://rubocop//lib/rubocop/cop/variable_force.rb#108 def skip_children!; end # @api private # - # source://rubocop//lib/rubocop/cop/variable_force.rb#277 + # source://rubocop//lib/rubocop/cop/variable_force.rb#278 def twisted_nodes(node); end end @@ -50352,12 +51422,22 @@ class RuboCop::Cop::VariableForce::Assignment # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#16 def initialize(node, variable); end - # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#67 + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#50 + def exception_assignment?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#72 + def for_assignment?; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#83 def meta_assignment_node; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#56 + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#60 def multiple_assignment?; end # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#29 @@ -50368,12 +51448,12 @@ class RuboCop::Cop::VariableForce::Assignment # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12 def node; end - # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#62 + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#78 def operator; end # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#50 + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#54 def operator_assignment?; end # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#37 @@ -50399,6 +51479,11 @@ class RuboCop::Cop::VariableForce::Assignment # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#46 def regexp_named_capture?; end + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#66 + def rest_assignment?; end + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#33 def scope; end @@ -50414,11 +51499,20 @@ class RuboCop::Cop::VariableForce::Assignment private - # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#85 + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#127 + def find_multiple_assignment_node(grandparent_node); end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#121 + def for_assignment_node; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#104 def multiple_assignment_node; end - # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#77 + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#96 def operator_assignment_node; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#114 + def rest_assignment_node; end end # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#10 @@ -50426,12 +51520,12 @@ RuboCop::Cop::VariableForce::Assignment::MULTIPLE_LEFT_HAND_SIDE_TYPE = T.let(T. # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#64 +# source://rubocop//lib/rubocop/cop/variable_force.rb#65 class RuboCop::Cop::VariableForce::AssignmentReference < ::Struct # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/variable_force.rb#65 + # source://rubocop//lib/rubocop/cop/variable_force.rb#66 def assignment?; end # Returns the value of attribute node @@ -50876,7 +51970,7 @@ RuboCop::Cop::VariableForce::LOGICAL_OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe( # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#47 +# source://rubocop//lib/rubocop/cop/variable_force.rb#48 RuboCop::Cop::VariableForce::LOOP_TYPES = T.let(T.unsafe(nil), Array) # @api private @@ -50886,7 +51980,7 @@ RuboCop::Cop::VariableForce::MULTIPLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Sym # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#111 +# source://rubocop//lib/rubocop/cop/variable_force.rb#112 RuboCop::Cop::VariableForce::NODE_HANDLER_METHOD_NAMES = T.let(T.unsafe(nil), Hash) # @api private @@ -50896,7 +51990,7 @@ RuboCop::Cop::VariableForce::OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Ar # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#46 +# source://rubocop//lib/rubocop/cop/variable_force.rb#47 RuboCop::Cop::VariableForce::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array) # @api private @@ -50906,9 +52000,14 @@ RuboCop::Cop::VariableForce::REGEXP_NAMED_CAPTURE_TYPE = T.let(T.unsafe(nil), Sy # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#49 +# source://rubocop//lib/rubocop/cop/variable_force.rb#50 RuboCop::Cop::VariableForce::RESCUE_TYPE = T.let(T.unsafe(nil), Symbol) +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#43 +RuboCop::Cop::VariableForce::REST_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + # This class represents each reference of a variable. # # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#7 @@ -50956,12 +52055,12 @@ RuboCop::Cop::VariableForce::Reference::VARIABLE_REFERENCE_TYPES = T.let(T.unsaf # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#54 +# source://rubocop//lib/rubocop/cop/variable_force.rb#55 RuboCop::Cop::VariableForce::SCOPE_TYPES = T.let(T.unsafe(nil), Array) # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#56 +# source://rubocop//lib/rubocop/cop/variable_force.rb#57 RuboCop::Cop::VariableForce::SEND_TYPE = T.let(T.unsafe(nil), Symbol) # A Scope represents a context of local variable visibility. @@ -51040,7 +52139,7 @@ RuboCop::Cop::VariableForce::Scope::OUTER_SCOPE_CHILD_INDICES = T.let(T.unsafe(n # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#53 +# source://rubocop//lib/rubocop/cop/variable_force.rb#54 RuboCop::Cop::VariableForce::TWISTED_SCOPE_TYPES = T.let(T.unsafe(nil), Array) # @api private @@ -51055,7 +52154,7 @@ RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Ar # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#44 +# source://rubocop//lib/rubocop/cop/variable_force.rb#45 RuboCop::Cop::VariableForce::VARIABLE_REFERENCE_TYPE = T.let(T.unsafe(nil), Symbol) # A Variable represents existence of a local variable. @@ -51172,12 +52271,12 @@ RuboCop::Cop::VariableForce::Variable::VARIABLE_DECLARATION_TYPES = T.let(T.unsa # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#58 +# source://rubocop//lib/rubocop/cop/variable_force.rb#59 class RuboCop::Cop::VariableForce::VariableReference < ::Struct # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/cop/variable_force.rb#59 + # source://rubocop//lib/rubocop/cop/variable_force.rb#60 def assignment?; end # Returns the value of attribute name @@ -51259,7 +52358,7 @@ end # @api private # -# source://rubocop//lib/rubocop/cop/variable_force.rb#51 +# source://rubocop//lib/rubocop/cop/variable_force.rb#52 RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol) # Help methods for determining node visibility. @@ -51605,7 +52704,7 @@ end # source://rubocop//lib/rubocop/ext/regexp_node.rb#6 module RuboCop::Ext::RegexpNode # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped. - # It's for compatibility with regexp_arser 1.8 and will never be maintained. + # It's for compatibility with regexp_parser 1.8 and will never be maintained. # # source://rubocop//lib/rubocop/ext/regexp_node.rb#19 def assign_properties(*_arg0); end @@ -51680,9 +52779,9 @@ end # Provide `CharacterSet` with `begin` and `end` locations. # -# source://rubocop//lib/rubocop/ext/regexp_parser.rb#77 +# source://rubocop//lib/rubocop/ext/regexp_parser.rb#79 module RuboCop::Ext::RegexpParser::Expression::CharacterSet - # source://rubocop//lib/rubocop/ext/regexp_parser.rb#78 + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#80 def build_location; end end @@ -53028,6 +54127,216 @@ class RuboCop::Lockfile def parser; end end +# source://rubocop//lib/rubocop/lsp/logger.rb#13 +module RuboCop::Lsp; end + +# Log for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/logger.rb#16 +class RuboCop::Lsp::Logger + class << self + # @api private + # + # source://rubocop//lib/rubocop/lsp/logger.rb#17 + def log(message); end + end +end + +# Routes for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/routes.rb#18 +class RuboCop::Lsp::Routes + # @api private + # @return [Routes] a new instance of Routes + # + # source://rubocop//lib/rubocop/lsp/routes.rb#25 + def initialize(server); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#31 + def for(name); end + + # source://rubocop//lib/rubocop/lsp/routes.rb#38 + def handle_initialize(request); end + + # source://rubocop//lib/rubocop/lsp/routes.rb#56 + def handle_initialized(_request); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#159 + def handle_method_missing(request); end + + # source://rubocop//lib/rubocop/lsp/routes.rb#62 + def handle_shutdown(request); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#148 + def handle_unsupported_method(request, method = T.unsafe(nil)); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#193 + def diagnostic(file_uri, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#173 + def format_file(file_uri); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#207 + def remove_file_protocol_from(uri); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/lsp/routes.rb#167 + def safe_autocorrect?(request); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#211 + def to_diagnostic(offense); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#223 + def to_range(location); end + + class << self + private + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#19 + def handle(name, &block); end + end +end + +# Runtime for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/runtime.rb#16 +class RuboCop::Lsp::Runtime + # @api private + # @return [Runtime] a new instance of Runtime + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#19 + def initialize(config_store); end + + # This abuses the `--stdin` option of rubocop and reads the formatted text + # from the `options[:stdin]` that rubocop mutates. This depends on + # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup + # or reassign that options object. Risky business! + # + # Reassigning `options[:stdin]` is done here: + # https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131 + # Printing `options[:stdin]` + # https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95 + # Setting `parallel: true` would break this here: + # https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72 + # + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#36 + def format(path, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#46 + def offenses(path, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#17 + def safe_autocorrect=(_arg0); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#67 + def redirect_stdout(&block); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#75 + def run_rubocop(options, path); end +end + +# Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/server.rb#21 +class RuboCop::Lsp::Server + # @api private + # @return [Server] a new instance of Server + # + # source://rubocop//lib/rubocop/lsp/server.rb#22 + def initialize(config_store); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#56 + def configure(safe_autocorrect: T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#48 + def format(path, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#52 + def offenses(path, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#29 + def start; end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#60 + def stop(&block); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#44 + def write(response); end +end + +# Severity for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/severity.rb#7 +class RuboCop::Lsp::Severity + class << self + # @api private + # + # source://rubocop//lib/rubocop/lsp/severity.rb#17 + def find_by(rubocop_severity); end + end +end + +# @api private +# +# source://rubocop//lib/rubocop/lsp/severity.rb#8 +RuboCop::Lsp::Severity::SEVERITIES = T.let(T.unsafe(nil), Hash) + # Parse different formats of magic comments. # # @abstract parent of three different magic comment handlers @@ -53230,7 +54539,7 @@ RuboCop::MagicComment::KEYWORDS = T.let(T.unsafe(nil), Hash) # comment2.frozen_string_literal # => nil # comment2.encoding # => 'utf-8' # -# source://rubocop//lib/rubocop/magic_comment.rb#262 +# source://rubocop//lib/rubocop/magic_comment.rb#261 class RuboCop::MagicComment::SimpleComment < ::RuboCop::MagicComment # Match `encoding` or `coding` # @@ -53382,7 +54691,7 @@ class RuboCop::Options # @api private # - # source://rubocop//lib/rubocop/options.rb#216 + # source://rubocop//lib/rubocop/options.rb#228 def add_additional_modes(opts); end # the autocorrect command-line arguments map to the autocorrect @options values like so: @@ -53394,62 +54703,67 @@ class RuboCop::Options # # @api private # - # source://rubocop//lib/rubocop/options.rb#136 + # source://rubocop//lib/rubocop/options.rb#139 def add_autocorrection_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#198 + # source://rubocop//lib/rubocop/options.rb#204 def add_cache_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#70 + # source://rubocop//lib/rubocop/options.rb#73 def add_check_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#159 + # source://rubocop//lib/rubocop/options.rb#162 def add_config_generation_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#177 + # source://rubocop//lib/rubocop/options.rb#180 def add_cop_selection_csv_option(option, opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#228 + # source://rubocop//lib/rubocop/options.rb#240 def add_general_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#101 + # source://rubocop//lib/rubocop/options.rb#211 + def add_lsp_option(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#104 def add_output_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#240 + # source://rubocop//lib/rubocop/options.rb#252 def add_profile_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#205 + # source://rubocop//lib/rubocop/options.rb#217 def add_server_options(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#189 + # source://rubocop//lib/rubocop/options.rb#195 def add_severity_option(opts); end # @api private # - # source://rubocop//lib/rubocop/options.rb#52 + # source://rubocop//lib/rubocop/options.rb#53 def define_options; end # @api private # - # source://rubocop//lib/rubocop/options.rb#250 + # source://rubocop//lib/rubocop/options.rb#262 def handle_deprecated_option(old_option, new_option); end # Finds the option in `args` starting with -- and converts it to a symbol, @@ -53457,7 +54771,7 @@ class RuboCop::Options # # @api private # - # source://rubocop//lib/rubocop/options.rb#284 + # source://rubocop//lib/rubocop/options.rb#296 def long_opt_symbol(args); end # Sets a value in the @options hash, based on the given long option and its @@ -53465,17 +54779,17 @@ class RuboCop::Options # # @api private # - # source://rubocop//lib/rubocop/options.rb#273 + # source://rubocop//lib/rubocop/options.rb#285 def option(opts, *args); end # @api private # - # source://rubocop//lib/rubocop/options.rb#255 + # source://rubocop//lib/rubocop/options.rb#267 def rainbow; end # @api private # - # source://rubocop//lib/rubocop/options.rb#289 + # source://rubocop//lib/rubocop/options.rb#301 def require_feature(file); end # Creates a section of options in order to separate them visually when @@ -53483,7 +54797,7 @@ class RuboCop::Options # # @api private # - # source://rubocop//lib/rubocop/options.rb#265 + # source://rubocop//lib/rubocop/options.rb#277 def section(opts, heading, &_block); end end @@ -53506,125 +54820,125 @@ RuboCop::Options::E_STDIN_NO_PATH = T.let(T.unsafe(nil), String) # # @api private # -# source://rubocop//lib/rubocop/options.rb#485 +# source://rubocop//lib/rubocop/options.rb#497 module RuboCop::OptionsHelp; end # @api private # -# source://rubocop//lib/rubocop/options.rb#487 +# source://rubocop//lib/rubocop/options.rb#499 RuboCop::OptionsHelp::FORMATTER_OPTION_LIST = T.let(T.unsafe(nil), Array) # @api private # -# source://rubocop//lib/rubocop/options.rb#486 +# source://rubocop//lib/rubocop/options.rb#498 RuboCop::OptionsHelp::MAX_EXCL = T.let(T.unsafe(nil), String) # @api private # -# source://rubocop//lib/rubocop/options.rb#489 +# source://rubocop//lib/rubocop/options.rb#501 RuboCop::OptionsHelp::TEXT = T.let(T.unsafe(nil), Hash) # Validates option arguments and the options' compatibility with each other. # # @api private # -# source://rubocop//lib/rubocop/options.rb#299 +# source://rubocop//lib/rubocop/options.rb#311 class RuboCop::OptionsValidator # @api private # @return [OptionsValidator] a new instance of OptionsValidator # - # source://rubocop//lib/rubocop/options.rb#337 + # source://rubocop//lib/rubocop/options.rb#349 def initialize(options); end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/options.rb#459 + # source://rubocop//lib/rubocop/options.rb#471 def boolean_or_empty_cache?; end # @api private # - # source://rubocop//lib/rubocop/options.rb#425 + # source://rubocop//lib/rubocop/options.rb#437 def disable_parallel_when_invalid_option_combo; end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/options.rb#451 + # source://rubocop//lib/rubocop/options.rb#463 def display_only_fail_level_offenses_with_autocorrect?; end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/options.rb#455 + # source://rubocop//lib/rubocop/options.rb#467 def except_syntax?; end # @api private # - # source://rubocop//lib/rubocop/options.rb#463 + # source://rubocop//lib/rubocop/options.rb#475 def incompatible_options; end # @api private # - # source://rubocop//lib/rubocop/options.rb#438 + # source://rubocop//lib/rubocop/options.rb#450 def invalid_arguments_for_parallel; end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/options.rb#446 + # source://rubocop//lib/rubocop/options.rb#458 def only_includes_redundant_disable?; end # @api private # - # source://rubocop//lib/rubocop/options.rb#372 + # source://rubocop//lib/rubocop/options.rb#384 def validate_auto_gen_config; end # @api private # @raise [OptionArgumentError] # - # source://rubocop//lib/rubocop/options.rb#411 + # source://rubocop//lib/rubocop/options.rb#423 def validate_autocorrect; end # @api private # @raise [OptionArgumentError] # - # source://rubocop//lib/rubocop/options.rb#475 + # source://rubocop//lib/rubocop/options.rb#487 def validate_cache_enabled_for_cache_root; end # @api private # @raise [OptionArgumentError] # - # source://rubocop//lib/rubocop/options.rb#346 + # source://rubocop//lib/rubocop/options.rb#358 def validate_compatibility; end # @api private # - # source://rubocop//lib/rubocop/options.rb#341 + # source://rubocop//lib/rubocop/options.rb#353 def validate_cop_options; end # @api private # @raise [OptionArgumentError] # - # source://rubocop//lib/rubocop/options.rb#393 + # source://rubocop//lib/rubocop/options.rb#405 def validate_display_only_correctable_and_autocorrect; end # @api private # @raise [OptionArgumentError] # - # source://rubocop//lib/rubocop/options.rb#385 + # source://rubocop//lib/rubocop/options.rb#397 def validate_display_only_failed; end # @api private # @raise [OptionArgumentError] # - # source://rubocop//lib/rubocop/options.rb#402 + # source://rubocop//lib/rubocop/options.rb#414 def validate_display_only_failed_and_display_only_correctable; end # @api private # @raise [OptionParser::MissingArgument] # - # source://rubocop//lib/rubocop/options.rb#467 + # source://rubocop//lib/rubocop/options.rb#479 def validate_exclude_limit_option; end class << self @@ -53633,14 +54947,14 @@ class RuboCop::OptionsValidator # # @api private # - # source://rubocop//lib/rubocop/options.rb#306 + # source://rubocop//lib/rubocop/options.rb#318 def validate_cop_list(names); end private # @api private # - # source://rubocop//lib/rubocop/options.rb#323 + # source://rubocop//lib/rubocop/options.rb#335 def format_message_from(name, cop_names); end end end @@ -54461,34 +55775,34 @@ class RuboCop::TargetRuby # @api private # @return [TargetRuby] a new instance of TargetRuby # - # source://rubocop//lib/rubocop/target_ruby.rb#247 + # source://rubocop//lib/rubocop/target_ruby.rb#248 def initialize(config); end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#263 + # source://rubocop//lib/rubocop/target_ruby.rb#264 def rubocop_version_with_support; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#251 + # source://rubocop//lib/rubocop/target_ruby.rb#252 def source; end # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/target_ruby.rb#259 + # source://rubocop//lib/rubocop/target_ruby.rb#260 def supported?; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#255 + # source://rubocop//lib/rubocop/target_ruby.rb#256 def version; end class << self # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#233 + # source://rubocop//lib/rubocop/target_ruby.rb#234 def supported_versions; end end end @@ -54497,23 +55811,23 @@ end # # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#106 +# source://rubocop//lib/rubocop/target_ruby.rb#107 class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#107 + # source://rubocop//lib/rubocop/target_ruby.rb#108 def name; end private # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#140 + # source://rubocop//lib/rubocop/target_ruby.rb#141 def bundler_lock_file_path; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#113 + # source://rubocop//lib/rubocop/target_ruby.rb#114 def find_version; end end @@ -54526,18 +55840,18 @@ RuboCop::TargetRuby::DEFAULT_VERSION = T.let(T.unsafe(nil), Float) # # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#221 +# source://rubocop//lib/rubocop/target_ruby.rb#222 class RuboCop::TargetRuby::Default < ::RuboCop::TargetRuby::Source # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#222 + # source://rubocop//lib/rubocop/target_ruby.rb#223 def name; end private # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#228 + # source://rubocop//lib/rubocop/target_ruby.rb#229 def find_version; end end @@ -54545,62 +55859,62 @@ end # # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#147 +# source://rubocop//lib/rubocop/target_ruby.rb#148 class RuboCop::TargetRuby::GemspecFile < ::RuboCop::TargetRuby::Source extend ::RuboCop::AST::NodePattern::Macros - # source://rubocop//lib/rubocop/target_ruby.rb#158 + # source://rubocop//lib/rubocop/target_ruby.rb#159 def gem_requirement?(param0 = T.unsafe(nil)); end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#162 + # source://rubocop//lib/rubocop/target_ruby.rb#163 def name; end - # source://rubocop//lib/rubocop/target_ruby.rb#153 + # source://rubocop//lib/rubocop/target_ruby.rb#154 def required_ruby_version(param0); end private # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#209 + # source://rubocop//lib/rubocop/target_ruby.rb#210 def find_default_minimal_known_ruby(right_hand_side); end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#168 + # source://rubocop//lib/rubocop/target_ruby.rb#169 def find_version; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#178 + # source://rubocop//lib/rubocop/target_ruby.rb#179 def gemspec_filename; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#185 + # source://rubocop//lib/rubocop/target_ruby.rb#186 def gemspec_filepath; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#205 + # source://rubocop//lib/rubocop/target_ruby.rb#206 def version_from_array(array); end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#190 + # source://rubocop//lib/rubocop/target_ruby.rb#191 def version_from_gemspec_file(file); end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#195 + # source://rubocop//lib/rubocop/target_ruby.rb#196 def version_from_right_hand_side(right_hand_side); end end # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#150 +# source://rubocop//lib/rubocop/target_ruby.rb#151 RuboCop::TargetRuby::GemspecFile::GEMSPEC_EXTENSION = T.let(T.unsafe(nil), String) # @api private @@ -54617,18 +55931,18 @@ RuboCop::TargetRuby::OBSOLETE_RUBIES = T.let(T.unsafe(nil), Hash) # # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#38 +# source://rubocop//lib/rubocop/target_ruby.rb#39 class RuboCop::TargetRuby::RuboCopConfig < ::RuboCop::TargetRuby::Source # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#39 + # source://rubocop//lib/rubocop/target_ruby.rb#40 def name; end private # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#45 + # source://rubocop//lib/rubocop/target_ruby.rb#46 def find_version; end end @@ -54636,76 +55950,76 @@ end # # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#52 +# source://rubocop//lib/rubocop/target_ruby.rb#53 class RuboCop::TargetRuby::RubyVersionFile < ::RuboCop::TargetRuby::Source # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#56 + # source://rubocop//lib/rubocop/target_ruby.rb#57 def name; end private # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#62 + # source://rubocop//lib/rubocop/target_ruby.rb#63 def filename; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#70 + # source://rubocop//lib/rubocop/target_ruby.rb#71 def find_version; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#66 + # source://rubocop//lib/rubocop/target_ruby.rb#67 def pattern; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#77 + # source://rubocop//lib/rubocop/target_ruby.rb#78 def version_file; end end # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#53 +# source://rubocop//lib/rubocop/target_ruby.rb#54 RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_FILENAME = T.let(T.unsafe(nil), String) # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#54 +# source://rubocop//lib/rubocop/target_ruby.rb#55 RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#237 +# source://rubocop//lib/rubocop/target_ruby.rb#238 RuboCop::TargetRuby::SOURCES = T.let(T.unsafe(nil), Array) # A place where information about a target ruby version is found. # # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#23 +# source://rubocop//lib/rubocop/target_ruby.rb#24 class RuboCop::TargetRuby::Source # @api private # @return [Source] a new instance of Source # - # source://rubocop//lib/rubocop/target_ruby.rb#26 + # source://rubocop//lib/rubocop/target_ruby.rb#27 def initialize(config); end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#24 + # source://rubocop//lib/rubocop/target_ruby.rb#25 def name; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#31 + # source://rubocop//lib/rubocop/target_ruby.rb#32 def to_s; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#24 + # source://rubocop//lib/rubocop/target_ruby.rb#25 def version; end end @@ -54714,34 +56028,34 @@ end # # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#85 +# source://rubocop//lib/rubocop/target_ruby.rb#86 class RuboCop::TargetRuby::ToolVersionsFile < ::RuboCop::TargetRuby::RubyVersionFile # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#89 + # source://rubocop//lib/rubocop/target_ruby.rb#90 def name; end private # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#95 + # source://rubocop//lib/rubocop/target_ruby.rb#96 def filename; end # @api private # - # source://rubocop//lib/rubocop/target_ruby.rb#99 + # source://rubocop//lib/rubocop/target_ruby.rb#100 def pattern; end end # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#86 +# source://rubocop//lib/rubocop/target_ruby.rb#87 RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_FILENAME = T.let(T.unsafe(nil), String) # @api private # -# source://rubocop//lib/rubocop/target_ruby.rb#87 +# source://rubocop//lib/rubocop/target_ruby.rb#88 RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_PATTERN = T.let(T.unsafe(nil), Regexp) # source://rubocop//lib/rubocop/ast_aliases.rb#7 @@ -54767,12 +56081,12 @@ module RuboCop::Version class << self # @api private # - # source://rubocop//lib/rubocop/version.rb#89 + # source://rubocop//lib/rubocop/version.rb#93 def document_version; end # @api private # - # source://rubocop//lib/rubocop/version.rb#39 + # source://rubocop//lib/rubocop/version.rb#43 def extension_versions(env); end # Returns feature version in one of two ways: @@ -54782,17 +56096,17 @@ module RuboCop::Version # # @api private # - # source://rubocop//lib/rubocop/version.rb#73 + # source://rubocop//lib/rubocop/version.rb#77 def feature_version(feature); end # @api private # - # source://rubocop//lib/rubocop/version.rb#94 + # source://rubocop//lib/rubocop/version.rb#98 def server_mode; end # @api private # - # source://rubocop//lib/rubocop/version.rb#17 + # source://rubocop//lib/rubocop/version.rb#21 def version(debug: T.unsafe(nil), env: T.unsafe(nil)); end end end @@ -54800,7 +56114,7 @@ end # source://rubocop//lib/rubocop/version.rb#12 RuboCop::Version::CANONICAL_FEATURE_NAMES = T.let(T.unsafe(nil), Hash) -# source://rubocop//lib/rubocop/version.rb#14 +# source://rubocop//lib/rubocop/version.rb#16 RuboCop::Version::EXTENSION_PATH_NAMES = T.let(T.unsafe(nil), Hash) # source://rubocop//lib/rubocop/version.rb#8 diff --git a/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi b/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi index 598477e5..fe14ff97 100644 --- a/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi +++ b/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi @@ -21,7 +21,7 @@ class ProgressBar::Base # source://ruby-progressbar//lib/ruby-progressbar/base.rb#45 def initialize(options = T.unsafe(nil)); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def clear(*args, **_arg1, &block); end # source://ruby-progressbar//lib/ruby-progressbar/base.rb#137 @@ -47,7 +47,7 @@ class ProgressBar::Base # source://ruby-progressbar//lib/ruby-progressbar/base.rb#199 def inspect; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def log(*args, **_arg1, &block); end # source://ruby-progressbar//lib/ruby-progressbar/base.rb#102 @@ -58,7 +58,7 @@ class ProgressBar::Base # source://ruby-progressbar//lib/ruby-progressbar/base.rb#123 def paused?; end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def progress(*args, **_arg1, &block); end # source://ruby-progressbar//lib/ruby-progressbar/base.rb#145 @@ -67,7 +67,7 @@ class ProgressBar::Base # source://ruby-progressbar//lib/ruby-progressbar/base.rb#153 def progress_mark=(mark); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def refresh(*args, **_arg1, &block); end # source://ruby-progressbar//lib/ruby-progressbar/base.rb#157 @@ -107,7 +107,7 @@ class ProgressBar::Base # source://ruby-progressbar//lib/ruby-progressbar/base.rb#169 def to_s(new_format = T.unsafe(nil)); end - # source://forwardable/1.3.2/forwardable.rb#229 + # source://forwardable/1.3.3/forwardable.rb#231 def total(*args, **_arg1, &block); end # source://ruby-progressbar//lib/ruby-progressbar/base.rb#149 diff --git a/sorbet/rbi/gems/spoom@1.2.1.rbi b/sorbet/rbi/gems/spoom@1.2.1.rbi index 8d484f7d..9393e9b4 100644 --- a/sorbet/rbi/gems/spoom@1.2.1.rbi +++ b/sorbet/rbi/gems/spoom@1.2.1.rbi @@ -221,22 +221,22 @@ class Spoom::Cli::Main < ::Thor # source://spoom//lib/spoom/cli.rb#61 def __print_version; end - # source://thor/1.2.1/lib/thor.rb#239 + # source://thor/1.2.2/lib/thor.rb#239 def bump(*args); end - # source://thor/1.2.1/lib/thor.rb#239 + # source://thor/1.2.2/lib/thor.rb#239 def config(*args); end - # source://thor/1.2.1/lib/thor.rb#239 + # source://thor/1.2.2/lib/thor.rb#239 def coverage(*args); end # source://spoom//lib/spoom/cli.rb#43 def files; end - # source://thor/1.2.1/lib/thor.rb#239 + # source://thor/1.2.2/lib/thor.rb#239 def lsp(*args); end - # source://thor/1.2.1/lib/thor.rb#239 + # source://thor/1.2.2/lib/thor.rb#239 def tc(*args); end class << self @@ -713,6 +713,11 @@ class Spoom::Coverage::Cards::Erb < ::Spoom::Coverage::Cards::Card # source://spoom//lib/spoom/coverage/report.rb#115 sig { override.returns(::String) } def html; end + + class << self + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end + end end # source://spoom//lib/spoom/coverage/report.rb#153 @@ -864,6 +869,9 @@ class Spoom::Coverage::D3::Base # source://spoom//lib/spoom/coverage/d3/base.rb#26 sig { returns(::String) } def header_style; end + + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end end end @@ -926,7 +934,7 @@ class Spoom::Coverage::D3::ColorPalette < ::T::Struct prop :strong, ::String class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -953,6 +961,9 @@ class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base # source://spoom//lib/spoom/coverage/d3/pie.rb#25 sig { returns(::String) } def header_style; end + + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end end end @@ -1045,6 +1056,9 @@ class Spoom::Coverage::D3::Timeline < ::Spoom::Coverage::D3::Base # source://spoom//lib/spoom/coverage/d3/timeline.rb#25 sig { returns(::String) } def header_style; end + + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end end end @@ -1125,9 +1139,6 @@ end class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline abstract! - # source://sorbet-runtime/0.5.10741/lib/types/private/abstract/declare.rb#37 - def initialize(*args, **_arg1, &blk); end - # source://spoom//lib/spoom/coverage/d3/timeline.rb#388 sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) } def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end @@ -1139,6 +1150,11 @@ class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline # source://spoom//lib/spoom/coverage/d3/timeline.rb#336 sig { override.returns(::String) } def script; end + + class << self + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end + end end # source://spoom//lib/spoom/coverage/d3/timeline.rb#232 @@ -1199,6 +1215,11 @@ class Spoom::Coverage::Page < ::Spoom::Coverage::Template # source://spoom//lib/spoom/coverage/report.rb#47 sig { returns(::String) } def title; end + + class << self + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end + end end # source://spoom//lib/spoom/coverage/report.rb#44 @@ -1269,7 +1290,7 @@ class Spoom::Coverage::Snapshot < ::T::Struct sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) } def from_obj(obj); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1319,6 +1340,11 @@ class Spoom::Coverage::Template # source://spoom//lib/spoom/coverage/report.rb#28 sig { returns(::String) } def html; end + + class << self + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end + end end # source://spoom//lib/spoom.rb#12 @@ -1336,7 +1362,7 @@ class Spoom::ExecResult < ::T::Struct def to_s; end class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1530,7 +1556,7 @@ class Spoom::FileTree::Node < ::T::Struct def path; end class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1570,9 +1596,6 @@ end class Spoom::FileTree::Visitor abstract! - # source://sorbet-runtime/0.5.10741/lib/types/private/abstract/declare.rb#37 - def initialize(*args, **_arg1, &blk); end - # source://spoom//lib/spoom/file_tree.rb#129 sig { params(node: ::Spoom::FileTree::Node).void } def visit_node(node); end @@ -1584,6 +1607,11 @@ class Spoom::FileTree::Visitor # source://spoom//lib/spoom/file_tree.rb#124 sig { params(tree: ::Spoom::FileTree).void } def visit_tree(tree); end + + class << self + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end + end end # source://spoom//lib/spoom/context/git.rb#5 @@ -1599,7 +1627,7 @@ class Spoom::Git::Commit < ::T::Struct def timestamp; end class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end # Parse a line formated as `%h %at` into a `Commit` @@ -1711,7 +1739,7 @@ class Spoom::LSP::Diagnostic < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) } def from_json(json); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1744,7 +1772,7 @@ class Spoom::LSP::DocumentSymbol < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) } def from_json(json); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1802,7 +1830,7 @@ class Spoom::LSP::Hover < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) } def from_json(json); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1827,7 +1855,7 @@ class Spoom::LSP::Location < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) } def from_json(json); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1894,7 +1922,7 @@ class Spoom::LSP::Position < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) } def from_json(json); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -1932,7 +1960,7 @@ class Spoom::LSP::Range < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) } def from_json(json); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -2002,7 +2030,7 @@ class Spoom::LSP::SignatureHelp < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) } def from_json(json); end - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end @@ -2125,6 +2153,11 @@ class Spoom::Printer # source://spoom//lib/spoom/printer.rb#74 sig { void } def printt; end + + class << self + # source://sorbet-runtime/0.5.10875/lib/types/private/abstract/declare.rb#37 + def new(*args, **_arg1, &blk); end + end end # source://spoom//lib/spoom.rb#10 diff --git a/sorbet/rbi/gems/tapioca@0.11.4.rbi b/sorbet/rbi/gems/tapioca@0.11.7.rbi similarity index 89% rename from sorbet/rbi/gems/tapioca@0.11.4.rbi rename to sorbet/rbi/gems/tapioca@0.11.7.rbi index 8906f567..1b1a0ffc 100644 --- a/sorbet/rbi/gems/tapioca@0.11.4.rbi +++ b/sorbet/rbi/gems/tapioca@0.11.7.rbi @@ -5,7 +5,7 @@ # Please instead update this file by running `bin/tapioca gem tapioca`. class Bundler::Dependency < ::Gem::Dependency - include ::Tapioca::Gemfile::AutoRequireHook + include ::Tapioca::BundlerExt::AutoRequireHook end # We need to do the alias-method-chain dance since Bootsnap does the same, @@ -35,7 +35,7 @@ module RBI; end # source://tapioca//lib/tapioca/rbi_ext/model.rb#5 class RBI::Tree < ::RBI::NodeWithComments - # source://rbi/0.0.16/lib/rbi/model.rb#115 + # source://rbi/0.0.17/lib/rbi/model.rb#119 sig do params( loc: T.nilable(::RBI::Loc), @@ -45,19 +45,19 @@ class RBI::Tree < ::RBI::NodeWithComments end def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # source://rbi/0.0.16/lib/rbi/model.rb#122 + # source://rbi/0.0.17/lib/rbi/model.rb#126 sig { params(node: ::RBI::Node).void } def <<(node); end - # source://rbi/0.0.16/lib/rbi/printer.rb#224 + # source://rbi/0.0.17/lib/rbi/printer.rb#226 sig { override.params(v: ::RBI::Printer).void } def accept_printer(v); end - # source://rbi/0.0.16/lib/rbi/rewriters/add_sig_templates.rb#66 + # source://rbi/0.0.17/lib/rbi/rewriters/add_sig_templates.rb#66 sig { params(with_todo_comment: T::Boolean).void } def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end - # source://rbi/0.0.16/lib/rbi/rewriters/annotate.rb#48 + # source://rbi/0.0.17/lib/rbi/rewriters/annotate.rb#49 sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void } def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end @@ -121,23 +121,23 @@ class RBI::Tree < ::RBI::NodeWithComments end def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end - # source://rbi/0.0.16/lib/rbi/rewriters/deannotate.rb#40 + # source://rbi/0.0.17/lib/rbi/rewriters/deannotate.rb#41 sig { params(annotation: ::String).void } def deannotate!(annotation); end - # source://rbi/0.0.16/lib/rbi/model.rb#128 + # source://rbi/0.0.17/lib/rbi/model.rb#132 sig { returns(T::Boolean) } def empty?; end - # source://rbi/0.0.16/lib/rbi/rewriters/group_nodes.rb#38 + # source://rbi/0.0.17/lib/rbi/rewriters/group_nodes.rb#38 sig { void } def group_nodes!; end - # source://rbi/0.0.16/lib/rbi/index.rb#64 + # source://rbi/0.0.17/lib/rbi/index.rb#68 sig { returns(::RBI::Index) } def index; end - # source://rbi/0.0.16/lib/rbi/rewriters/merge_trees.rb#318 + # source://rbi/0.0.17/lib/rbi/rewriters/merge_trees.rb#324 sig do params( other: ::RBI::Tree, @@ -148,23 +148,23 @@ class RBI::Tree < ::RBI::NodeWithComments end def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end - # source://rbi/0.0.16/lib/rbi/rewriters/nest_non_public_methods.rb#45 + # source://rbi/0.0.17/lib/rbi/rewriters/nest_non_public_methods.rb#46 sig { void } def nest_non_public_methods!; end - # source://rbi/0.0.16/lib/rbi/rewriters/nest_singleton_methods.rb#35 + # source://rbi/0.0.17/lib/rbi/rewriters/nest_singleton_methods.rb#36 sig { void } def nest_singleton_methods!; end - # source://rbi/0.0.16/lib/rbi/model.rb#106 + # source://rbi/0.0.17/lib/rbi/model.rb#110 sig { returns(T::Array[::RBI::Node]) } def nodes; end - # source://rbi/0.0.16/lib/rbi/printer.rb#231 + # source://rbi/0.0.17/lib/rbi/printer.rb#233 sig { override.returns(T::Boolean) } def oneline?; end - # source://rbi/0.0.16/lib/rbi/rewriters/sort_nodes.rb#118 + # source://rbi/0.0.17/lib/rbi/rewriters/sort_nodes.rb#119 sig { void } def sort_nodes!; end @@ -185,16 +185,21 @@ class RBI::TypedParam < ::T::Struct const :type, ::String class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10908/lib/types/struct.rb#13 def inherited(s); end end end # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#5 module T::Generic + include ::Kernel + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#13 def [](*types); end + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#53 + def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#21 def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end @@ -214,6 +219,9 @@ module T::Generic::TypeStoragePatch # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#13 def [](*types); end + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#53 + def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#21 def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end @@ -302,18 +310,18 @@ end # source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#6 class T::Types::Simple < ::T::Types::Base - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#64 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#79 def name; end end -# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#59 +# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#74 module T::Types::Simple::GenericPatch # This method intercepts calls to the `name` method for simple types, so that # it can ask the name to the type if the type is generic, since, by this point, # we've created a clone of that type with the `name` method returning the # appropriate name for that specific concrete type. # - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#64 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#79 def name; end end @@ -329,17 +337,17 @@ end # source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#8 T::Types::Simple::NamePatch::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod) -# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#84 +# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#99 module T::Utils::Private class << self - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#86 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#101 def coerce_and_check_module_types(val, check_val, check_module_type); end end end -# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#85 +# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#100 module T::Utils::Private::PrivateCoercePatch - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#86 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#101 def coerce_and_check_module_types(val, check_val, check_module_type); end end @@ -360,6 +368,43 @@ end # source://tapioca//lib/tapioca.rb#37 Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String) +# source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#5 +module Tapioca::BundlerExt; end + +# This is a module that gets prepended to `Bundler::Dependency` and +# makes sure even gems marked as `require: false` are required during +# `Bundler.require`. +# +# source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#9 +module Tapioca::BundlerExt::AutoRequireHook + requires_ancestor { Bundler::Dependency } + + # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#46 + sig { returns(T.untyped) } + def autorequire; end + + class << self + # @return [Boolean] + # + # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#26 + def enabled?; end + + # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#22 + sig { params(name: T.untyped).returns(T::Boolean) } + def excluded?(name); end + + # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#36 + sig do + type_parameters(:Result) + .params( + exclude: T::Array[::String], + blk: T.proc.returns(T.type_parameter(:Result)) + ).returns(T.type_parameter(:Result)) + end + def override_require_false(exclude:, &blk); end + end +end + # source://tapioca//lib/tapioca.rb#60 Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String) @@ -375,22 +420,22 @@ class Tapioca::Cli < ::Thor include ::Tapioca::ConfigHelper include ::Tapioca::EnvHelper - # source://tapioca//lib/tapioca/cli.rb#336 + # source://tapioca//lib/tapioca/cli.rb#346 def __print_version; end - # source://tapioca//lib/tapioca/cli.rb#316 + # source://tapioca//lib/tapioca/cli.rb#326 def annotations; end - # source://tapioca//lib/tapioca/cli.rb#286 + # source://tapioca//lib/tapioca/cli.rb#296 def check_shims; end # source://tapioca//lib/tapioca/cli.rb#41 def configure; end - # source://tapioca//lib/tapioca/cli.rb#133 + # source://tapioca//lib/tapioca/cli.rb#137 def dsl(*constant_or_paths); end - # source://tapioca//lib/tapioca/cli.rb#238 + # source://tapioca//lib/tapioca/cli.rb#247 def gem(*gems); end # source://tapioca//lib/tapioca/cli.rb#27 @@ -404,11 +449,11 @@ class Tapioca::Cli < ::Thor private - # source://tapioca//lib/tapioca/cli.rb#350 + # source://tapioca//lib/tapioca/cli.rb#360 def print_init_next_steps; end class << self - # source://tapioca//lib/tapioca/cli.rb#342 + # source://tapioca//lib/tapioca/cli.rb#352 def exit_on_failure?; end end end @@ -564,7 +609,7 @@ class Tapioca::Commands::Command sig { abstract.void } def execute; end - # source://thor/1.2.1/lib/thor/base.rb#139 + # source://thor/1.2.2/lib/thor/base.rb#139 sig { returns(::Thor::Actions) } def file_writer; end @@ -650,7 +695,7 @@ class Tapioca::Commands::Dsl < ::Tapioca::Commands::CommandWithoutTracker include ::Tapioca::SorbetHelper include ::Tapioca::RBIFilesHelper - # source://tapioca//lib/tapioca/commands/dsl.rb#29 + # source://tapioca//lib/tapioca/commands/dsl.rb#30 sig do params( requested_constants: T::Array[::String], @@ -667,26 +712,27 @@ class Tapioca::Commands::Dsl < ::Tapioca::Commands::CommandWithoutTracker auto_strictness: T::Boolean, gem_dir: ::String, rbi_formatter: ::Tapioca::RBIFormatter, - app_root: ::String + app_root: ::String, + halt_upon_load_error: T::Boolean ).void end - def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, should_verify: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), app_root: T.unsafe(nil)); end + def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, should_verify: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/commands/dsl.rb#93 + # source://tapioca//lib/tapioca/commands/dsl.rb#97 sig { override.void } def execute; end - # source://tapioca//lib/tapioca/commands/dsl.rb#66 + # source://tapioca//lib/tapioca/commands/dsl.rb#69 sig { void } def list_compilers; end private - # source://tapioca//lib/tapioca/commands/dsl.rb#325 + # source://tapioca//lib/tapioca/commands/dsl.rb#330 sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) } def build_error_for_files(cause, files); end - # source://tapioca//lib/tapioca/commands/dsl.rb#249 + # source://tapioca//lib/tapioca/commands/dsl.rb#254 sig do params( constant_name: ::String, @@ -697,63 +743,63 @@ class Tapioca::Commands::Dsl < ::Tapioca::Commands::CommandWithoutTracker end def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/commands/dsl.rb#187 + # source://tapioca//lib/tapioca/commands/dsl.rb#192 sig { params(constant_names: T::Array[::String], ignore_missing: T::Boolean).returns(T::Array[::Module]) } def constantize(constant_names, ignore_missing: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/commands/dsl.rb#210 + # source://tapioca//lib/tapioca/commands/dsl.rb#215 sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) } def constantize_compilers(compiler_names); end - # source://tapioca//lib/tapioca/commands/dsl.rb#385 + # source://tapioca//lib/tapioca/commands/dsl.rb#390 sig { returns(T::Array[::String]) } def constants_from_requested_paths; end - # source://tapioca//lib/tapioca/commands/dsl.rb#158 + # source://tapioca//lib/tapioca/commands/dsl.rb#163 sig { returns(::Tapioca::Dsl::Pipeline) } def create_pipeline; end - # source://tapioca//lib/tapioca/commands/dsl.rb#288 + # source://tapioca//lib/tapioca/commands/dsl.rb#293 sig { params(constant_name: ::String).returns(::Pathname) } def dsl_rbi_filename(constant_name); end - # source://tapioca//lib/tapioca/commands/dsl.rb#173 + # source://tapioca//lib/tapioca/commands/dsl.rb#178 sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) } def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/commands/dsl.rb#380 + # source://tapioca//lib/tapioca/commands/dsl.rb#385 sig { params(constant: ::String).returns(::String) } def generate_command_for(constant); end - # source://tapioca//lib/tapioca/commands/dsl.rb#267 + # source://tapioca//lib/tapioca/commands/dsl.rb#272 sig { params(dir: ::Pathname).void } def perform_dsl_verification(dir); end - # source://tapioca//lib/tapioca/commands/dsl.rb#276 + # source://tapioca//lib/tapioca/commands/dsl.rb#281 sig { params(files: T::Set[::Pathname]).void } def purge_stale_dsl_rbi_files(files); end - # source://tapioca//lib/tapioca/commands/dsl.rb#375 + # source://tapioca//lib/tapioca/commands/dsl.rb#380 sig { params(constant: ::String).returns(::String) } def rbi_filename_for(constant); end - # source://tapioca//lib/tapioca/commands/dsl.rb#356 + # source://tapioca//lib/tapioca/commands/dsl.rb#361 sig { params(path: ::Pathname).returns(T::Array[::Pathname]) } def rbi_files_in(path); end - # source://tapioca//lib/tapioca/commands/dsl.rb#334 + # source://tapioca//lib/tapioca/commands/dsl.rb#339 sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void } def report_diff_and_exit_if_out_of_date(diff, command); end - # source://tapioca//lib/tapioca/commands/dsl.rb#229 + # source://tapioca//lib/tapioca/commands/dsl.rb#234 sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) } def resolve(name); end - # source://tapioca//lib/tapioca/commands/dsl.rb#363 + # source://tapioca//lib/tapioca/commands/dsl.rb#368 sig { params(class_name: ::String).returns(::String) } def underscore(class_name); end - # source://tapioca//lib/tapioca/commands/dsl.rb#293 + # source://tapioca//lib/tapioca/commands/dsl.rb#298 sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) } def verify_dsl_rbi(tmp_dir:); end end @@ -763,7 +809,7 @@ class Tapioca::Commands::Gem < ::Tapioca::Commands::Command include ::Tapioca::SorbetHelper include ::Tapioca::RBIFilesHelper - # source://tapioca//lib/tapioca/commands/gem.rb#28 + # source://tapioca//lib/tapioca/commands/gem.rb#29 sig do params( gem_names: T::Array[::String], @@ -779,86 +825,87 @@ class Tapioca::Commands::Gem < ::Tapioca::Commands::Command number_of_workers: T.nilable(::Integer), auto_strictness: T::Boolean, dsl_dir: ::String, - rbi_formatter: ::Tapioca::RBIFormatter + rbi_formatter: ::Tapioca::RBIFormatter, + halt_upon_load_error: T::Boolean ).void end - def initialize(gem_names:, exclude:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil)); end + def initialize(gem_names:, exclude:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/commands/gem.rb#67 + # source://tapioca//lib/tapioca/commands/gem.rb#70 sig { override.void } def execute; end - # source://tapioca//lib/tapioca/commands/gem.rb#105 + # source://tapioca//lib/tapioca/commands/gem.rb#109 sig { params(should_verify: T::Boolean, exclude: T::Array[::String]).void } def sync(should_verify: T.unsafe(nil), exclude: T.unsafe(nil)); end private - # source://tapioca//lib/tapioca/commands/gem.rb#283 + # source://tapioca//lib/tapioca/commands/gem.rb#288 sig { returns(T::Array[::String]) } def added_rbis; end - # source://tapioca//lib/tapioca/commands/gem.rb#344 + # source://tapioca//lib/tapioca/commands/gem.rb#349 sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) } def build_error_for_files(cause, files); end - # source://tapioca//lib/tapioca/commands/gem.rb#154 + # source://tapioca//lib/tapioca/commands/gem.rb#158 sig { params(gem: ::Tapioca::Gemfile::GemSpec).void } def compile_gem_rbi(gem); end - # source://tapioca//lib/tapioca/commands/gem.rb#278 + # source://tapioca//lib/tapioca/commands/gem.rb#283 sig { params(gem_name: ::String).returns(::Pathname) } def existing_rbi(gem_name); end - # source://tapioca//lib/tapioca/commands/gem.rb#326 + # source://tapioca//lib/tapioca/commands/gem.rb#331 sig { returns(T::Hash[::String, ::String]) } def existing_rbis; end - # source://tapioca//lib/tapioca/commands/gem.rb#290 + # source://tapioca//lib/tapioca/commands/gem.rb#295 sig { params(gem_name: ::String).returns(::Pathname) } def expected_rbi(gem_name); end - # source://tapioca//lib/tapioca/commands/gem.rb#332 + # source://tapioca//lib/tapioca/commands/gem.rb#337 sig { returns(T::Hash[::String, ::String]) } def expected_rbis; end - # source://tapioca//lib/tapioca/commands/gem.rb#295 + # source://tapioca//lib/tapioca/commands/gem.rb#300 sig { params(gem_name: ::String).returns(T::Boolean) } def gem_rbi_exists?(gem_name); end - # source://tapioca//lib/tapioca/commands/gem.rb#339 + # source://tapioca//lib/tapioca/commands/gem.rb#344 sig { params(gem_name: ::String, version: ::String).returns(::Pathname) } def gem_rbi_filename(gem_name, version); end - # source://tapioca//lib/tapioca/commands/gem.rb#139 + # source://tapioca//lib/tapioca/commands/gem.rb#143 sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) } def gems_to_generate(gem_names); end - # source://tapioca//lib/tapioca/commands/gem.rb#349 + # source://tapioca//lib/tapioca/commands/gem.rb#354 sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void } def merge_with_exported_rbi(gem, file); end - # source://tapioca//lib/tapioca/commands/gem.rb#320 + # source://tapioca//lib/tapioca/commands/gem.rb#325 sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void } def move(old_filename, new_filename); end - # source://tapioca//lib/tapioca/commands/gem.rb#231 + # source://tapioca//lib/tapioca/commands/gem.rb#235 sig { void } def perform_additions; end - # source://tapioca//lib/tapioca/commands/gem.rb#204 + # source://tapioca//lib/tapioca/commands/gem.rb#208 sig { void } def perform_removals; end - # source://tapioca//lib/tapioca/commands/gem.rb#185 + # source://tapioca//lib/tapioca/commands/gem.rb#189 sig { params(exclude: T::Array[::String]).void } def perform_sync_verification(exclude: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/commands/gem.rb#273 + # source://tapioca//lib/tapioca/commands/gem.rb#278 sig { returns(T::Array[::String]) } def removed_rbis; end - # source://tapioca//lib/tapioca/commands/gem.rb#300 + # source://tapioca//lib/tapioca/commands/gem.rb#305 sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void } def report_diff_and_exit_if_out_of_date(diff, command); end end @@ -967,7 +1014,7 @@ class Tapioca::ConfigHelper::ConfigError < ::T::Struct const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart] class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10908/lib/types/struct.rb#13 def inherited(s); end end end @@ -978,7 +1025,7 @@ class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct const :colors, T::Array[::Symbol] class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10908/lib/types/struct.rb#13 def inherited(s); end end end @@ -1101,7 +1148,7 @@ class Tapioca::Dsl::Compiler private # source://tapioca//lib/tapioca/dsl/compiler.rb#47 - sig { returns(T::Enumerable[::Class]) } + sig { returns(T::Enumerable[T::Class[T.anything]]) } def all_classes; end # source://tapioca//lib/tapioca/dsl/compiler.rb#53 @@ -1241,6 +1288,12 @@ class Tapioca::Executor ).returns(T::Array[T.type_parameter(:T)]) end def run_in_parallel(&block); end + + private + + # source://tapioca//lib/tapioca/executor.rb#37 + sig { returns(::Integer) } + def max_processors; end end # source://tapioca//lib/tapioca/executor.rb#8 @@ -1280,9 +1333,6 @@ end # source://tapioca//lib/tapioca/gem/events.rb#6 class Tapioca::Gem::Event abstract! - - # source://sorbet-runtime/0.5.10741/lib/types/private/abstract/declare.rb#37 - def initialize(*args, **_arg1, &blk); end end # source://tapioca//lib/tapioca/gem/events.rb#43 @@ -1380,11 +1430,19 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base private - # source://tapioca//lib/tapioca/gem/listeners/methods.rb#34 - sig { params(tree: ::RBI::Tree, module_name: ::String, mod: ::Module, for_visibility: T::Array[::Symbol]).void } - def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil)); end + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#35 + sig do + params( + tree: ::RBI::Tree, + module_name: ::String, + mod: ::Module, + for_visibility: T::Array[::Symbol], + attached_class: T.nilable(::Module) + ).void + end + def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil), attached_class: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/gem/listeners/methods.rb#63 + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#71 sig do params( tree: ::RBI::Tree, @@ -1396,18 +1454,22 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base end def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end - # source://tapioca//lib/tapioca/gem/listeners/methods.rb#191 + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#212 sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } def ignore?(event); end - # source://tapioca//lib/tapioca/gem/listeners/methods.rb#184 + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#205 sig { params(constant: ::Module).returns(T.nilable(::UnboundMethod)) } def initialize_method_for(constant); end - # source://tapioca//lib/tapioca/gem/listeners/methods.rb#165 + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#173 sig { params(mod: ::Module).returns(T::Hash[::Symbol, T::Array[::Symbol]]) } def method_names_by_visibility(mod); end + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#197 + sig { params(attached_class: T.nilable(::Module), method_name: ::Symbol).returns(T.nilable(T::Boolean)) } + def method_new_in_abstract_class?(attached_class, method_name); end + # Check whether the method is defined by the constant. # # In most cases, it works to check that the constant is the method owner. However, @@ -1418,7 +1480,7 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base # It walks up the ancestor tree via the `super_method` method; if any of the super # methods are owned by the constant, it means that the constant declares the method. # - # source://tapioca//lib/tapioca/gem/listeners/methods.rb#151 + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#159 sig { params(method: ::UnboundMethod, constant: ::Module).returns(T::Boolean) } def method_owned_by_constant?(method, constant); end @@ -1426,7 +1488,7 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } def on_scope(event); end - # source://tapioca//lib/tapioca/gem/listeners/methods.rb#174 + # source://tapioca//lib/tapioca/gem/listeners/methods.rb#182 sig { params(constant: ::Module, method_name: ::String).returns(T::Boolean) } def struct_method?(constant, method_name); end end @@ -1508,7 +1570,7 @@ class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base private - # source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#28 + # source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#27 sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } def ignore?(event); end @@ -1583,10 +1645,14 @@ class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners:: sig { params(tree: ::RBI::Tree, constant: ::Module).void } def compile_type_variable_declarations(tree, constant); end - # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#50 + # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#63 sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } def ignore?(event); end + # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#50 + sig { params(type_variable: ::Tapioca::TypeVariableModule).returns(T.nilable(::RBI::Node)) } + def node_from_type_variable(type_variable); end + # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#15 sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } def on_scope(event); end @@ -1820,7 +1886,7 @@ class Tapioca::Gem::Pipeline def compile_object(name, value); end # source://tapioca//lib/tapioca/gem/pipeline.rb#308 - sig { params(constant: ::Class).returns(T.nilable(::String)) } + sig { params(constant: T::Class[T.anything]).returns(T.nilable(::String)) } def compile_superclass(constant); end # source://tapioca//lib/tapioca/gem/pipeline.rb#357 @@ -1922,189 +1988,166 @@ module Tapioca::GemHelper def path_in_dir?(path, dir); end end -# source://tapioca//lib/tapioca/gemfile.rb#5 +# source://tapioca//lib/tapioca/gemfile.rb#7 class Tapioca::Gemfile - # source://tapioca//lib/tapioca/gemfile.rb#69 - sig { params(exclude: T::Array[::String]).void } - def initialize(exclude); end + # source://tapioca//lib/tapioca/gemfile.rb#27 + sig { params(excluded_gems: T::Array[::String]).void } + def initialize(excluded_gems); end - # source://tapioca//lib/tapioca/gemfile.rb#60 + # source://tapioca//lib/tapioca/gemfile.rb#18 sig { returns(::Bundler::Definition) } def definition; end - # source://tapioca//lib/tapioca/gemfile.rb#63 + # source://tapioca//lib/tapioca/gemfile.rb#21 sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) } def dependencies; end - # source://tapioca//lib/tapioca/gemfile.rb#80 + # source://tapioca//lib/tapioca/gemfile.rb#40 sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) } def gem(gem_name); end - # source://tapioca//lib/tapioca/gemfile.rb#66 + # source://tapioca//lib/tapioca/gemfile.rb#24 sig { returns(T::Array[::String]) } def missing_specs; end - # source://tapioca//lib/tapioca/gemfile.rb#85 + # source://tapioca//lib/tapioca/gemfile.rb#45 sig { void } def require_bundle; end private - # source://tapioca//lib/tapioca/gemfile.rb#130 + # source://tapioca//lib/tapioca/gemfile.rb#92 sig { returns(::String) } def dir; end - # source://tapioca//lib/tapioca/gemfile.rb#92 + # source://tapioca//lib/tapioca/gemfile.rb#54 sig { returns(::File) } def gemfile; end - # source://tapioca//lib/tapioca/gemfile.rb#125 + # source://tapioca//lib/tapioca/gemfile.rb#87 sig { returns(T::Array[::Symbol]) } def groups; end - # source://tapioca//lib/tapioca/gemfile.rb#95 + # source://tapioca//lib/tapioca/gemfile.rb#57 sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) } def load_dependencies; end # @return [File] # - # source://tapioca//lib/tapioca/gemfile.rb#92 + # source://tapioca//lib/tapioca/gemfile.rb#54 def lockfile; end - # source://tapioca//lib/tapioca/gemfile.rb#106 + # source://tapioca//lib/tapioca/gemfile.rb#68 sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) } def materialize_deps; end - # source://tapioca//lib/tapioca/gemfile.rb#120 + # source://tapioca//lib/tapioca/gemfile.rb#82 sig { returns(::Bundler::Runtime) } def runtime; end end -# This is a module that gets prepended to `Bundler::Dependency` and -# makes sure even gems marked as `require: false` are required during -# `Bundler.require`. -# -# source://tapioca//lib/tapioca/gemfile.rb#18 -module Tapioca::Gemfile::AutoRequireHook - requires_ancestor { Bundler::Dependency } - - # source://tapioca//lib/tapioca/gemfile.rb#39 - sig { returns(T.untyped) } - def autorequire; end - - class << self - # source://tapioca//lib/tapioca/gemfile.rb#30 - sig { params(exclude: T::Array[::String]).returns(T::Array[::String]) } - def exclude=(exclude); end - - # source://tapioca//lib/tapioca/gemfile.rb#33 - sig { params(name: T.untyped).returns(T::Boolean) } - def excluded?(name); end - end -end - -# source://tapioca//lib/tapioca/gemfile.rb#134 +# source://tapioca//lib/tapioca/gemfile.rb#96 class Tapioca::Gemfile::GemSpec include ::Tapioca::GemHelper - # source://tapioca//lib/tapioca/gemfile.rb#173 + # source://tapioca//lib/tapioca/gemfile.rb#135 sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void } def initialize(spec); end - # source://tapioca//lib/tapioca/gemfile.rb#183 + # source://tapioca//lib/tapioca/gemfile.rb#145 sig { params(other: ::BasicObject).returns(T::Boolean) } def ==(other); end - # source://tapioca//lib/tapioca/gemfile.rb#203 + # source://tapioca//lib/tapioca/gemfile.rb#165 sig { params(path: ::String).returns(T::Boolean) } def contains_path?(path); end - # source://tapioca//lib/tapioca/gemfile.rb#222 + # source://tapioca//lib/tapioca/gemfile.rb#184 sig { returns(T::Boolean) } def export_rbi_files?; end - # source://tapioca//lib/tapioca/gemfile.rb#217 + # source://tapioca//lib/tapioca/gemfile.rb#179 sig { returns(T::Array[::String]) } def exported_rbi_files; end - # source://tapioca//lib/tapioca/gemfile.rb#227 + # source://tapioca//lib/tapioca/gemfile.rb#189 sig { returns(::RBI::MergeTree) } def exported_rbi_tree; end - # source://tapioca//lib/tapioca/gemfile.rb#170 + # source://tapioca//lib/tapioca/gemfile.rb#132 sig { returns(T::Array[::Pathname]) } def files; end - # source://tapioca//lib/tapioca/gemfile.rb#167 + # source://tapioca//lib/tapioca/gemfile.rb#129 sig { returns(::String) } def full_gem_path; end - # source://tapioca//lib/tapioca/gemfile.rb#188 + # source://tapioca//lib/tapioca/gemfile.rb#150 sig { params(gemfile_dir: ::String).returns(T::Boolean) } def ignore?(gemfile_dir); end - # source://tapioca//lib/tapioca/gemfile.rb#193 + # source://tapioca//lib/tapioca/gemfile.rb#155 sig { returns(::String) } def name; end - # source://tapioca//lib/tapioca/gemfile.rb#212 + # source://tapioca//lib/tapioca/gemfile.rb#174 sig { void } def parse_yard_docs; end - # source://tapioca//lib/tapioca/gemfile.rb#198 + # source://tapioca//lib/tapioca/gemfile.rb#160 sig { returns(::String) } def rbi_file_name; end - # source://tapioca//lib/tapioca/gemfile.rb#239 + # source://tapioca//lib/tapioca/gemfile.rb#201 sig { params(file: ::Pathname).returns(::Pathname) } def relative_path_for(file); end # @return [String] # - # source://tapioca//lib/tapioca/gemfile.rb#167 + # source://tapioca//lib/tapioca/gemfile.rb#129 def version; end private - # source://tapioca//lib/tapioca/gemfile.rb#250 + # source://tapioca//lib/tapioca/gemfile.rb#212 sig { returns(T::Array[::Pathname]) } def collect_files; end - # source://tapioca//lib/tapioca/gemfile.rb#265 + # source://tapioca//lib/tapioca/gemfile.rb#227 sig { returns(T.nilable(T::Boolean)) } def default_gem?; end - # source://tapioca//lib/tapioca/gemfile.rb#323 + # source://tapioca//lib/tapioca/gemfile.rb#285 sig { returns(T::Boolean) } def gem_ignored?; end - # source://tapioca//lib/tapioca/gemfile.rb#302 + # source://tapioca//lib/tapioca/gemfile.rb#264 sig { params(path: ::String).returns(T::Boolean) } def has_parent_gemspec?(path); end - # source://tapioca//lib/tapioca/gemfile.rb#270 + # source://tapioca//lib/tapioca/gemfile.rb#232 sig { returns(::Regexp) } def require_paths_prefix_matcher; end - # source://tapioca//lib/tapioca/gemfile.rb#281 + # source://tapioca//lib/tapioca/gemfile.rb#243 sig { params(file: ::String).returns(::Pathname) } def resolve_to_ruby_lib_dir(file); end - # source://tapioca//lib/tapioca/gemfile.rb#295 + # source://tapioca//lib/tapioca/gemfile.rb#257 sig { returns(::String) } def version_string; end class << self - # source://tapioca//lib/tapioca/gemfile.rb#142 + # source://tapioca//lib/tapioca/gemfile.rb#104 sig { returns(T::Hash[::String, ::Tapioca::Gemfile::GemSpec]) } def spec_lookup_by_file_path; end end end -# source://tapioca//lib/tapioca/gemfile.rb#154 +# source://tapioca//lib/tapioca/gemfile.rb#116 Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array) -# source://tapioca//lib/tapioca/gemfile.rb#8 +# source://tapioca//lib/tapioca/gemfile.rb#10 Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) } # source://tapioca//lib/tapioca/loaders/loader.rb#5 @@ -2112,73 +2155,89 @@ module Tapioca::Loaders; end # source://tapioca//lib/tapioca/loaders/dsl.rb#6 class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader - # source://tapioca//lib/tapioca/loaders/dsl.rb#29 - sig { params(tapioca_path: ::String, eager_load: T::Boolean, app_root: ::String).void } - def initialize(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil)); end + # source://tapioca//lib/tapioca/loaders/dsl.rb#38 + sig do + params( + tapioca_path: ::String, + eager_load: T::Boolean, + app_root: ::String, + halt_upon_load_error: T::Boolean + ).void + end + def initialize(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/loaders/dsl.rb#20 + # source://tapioca//lib/tapioca/loaders/dsl.rb#27 sig { override.void } def load; end protected - # source://tapioca//lib/tapioca/loaders/dsl.rb#61 + # source://tapioca//lib/tapioca/loaders/dsl.rb#71 sig { void } def load_application; end - # source://tapioca//lib/tapioca/loaders/dsl.rb#43 + # source://tapioca//lib/tapioca/loaders/dsl.rb#53 sig { void } def load_dsl_compilers; end - # source://tapioca//lib/tapioca/loaders/dsl.rb#38 + # source://tapioca//lib/tapioca/loaders/dsl.rb#48 sig { void } def load_dsl_extensions; end class << self - # source://tapioca//lib/tapioca/loaders/dsl.rb#13 - sig { params(tapioca_path: ::String, eager_load: T::Boolean, app_root: ::String).void } - def load_application(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil)); end + # source://tapioca//lib/tapioca/loaders/dsl.rb#15 + sig do + params( + tapioca_path: ::String, + eager_load: T::Boolean, + app_root: ::String, + halt_upon_load_error: T::Boolean + ).void + end + def load_application(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end end end # source://tapioca//lib/tapioca/loaders/gem.rb#6 class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader - # source://tapioca//lib/tapioca/loaders/gem.rb#46 + # source://tapioca//lib/tapioca/loaders/gem.rb#49 sig do params( bundle: ::Tapioca::Gemfile, prerequire: T.nilable(::String), postrequire: ::String, - default_command: ::String + default_command: ::String, + halt_upon_load_error: T::Boolean ).void end - def initialize(bundle:, prerequire:, postrequire:, default_command:); end + def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end - # source://tapioca//lib/tapioca/loaders/gem.rb#32 + # source://tapioca//lib/tapioca/loaders/gem.rb#34 sig { override.void } def load; end protected - # source://tapioca//lib/tapioca/loaders/gem.rb#76 + # source://tapioca//lib/tapioca/loaders/gem.rb#80 sig { params(file: ::String, error: ::LoadError).void } def explain_failed_require(file, error); end - # source://tapioca//lib/tapioca/loaders/gem.rb#56 + # source://tapioca//lib/tapioca/loaders/gem.rb#60 sig { void } def require_gem_file; end class << self - # source://tapioca//lib/tapioca/loaders/gem.rb#20 + # source://tapioca//lib/tapioca/loaders/gem.rb#21 sig do params( bundle: ::Tapioca::Gemfile, prerequire: T.nilable(::String), postrequire: ::String, - default_command: ::String + default_command: ::String, + halt_upon_load_error: T::Boolean ).void end - def load_application(bundle:, prerequire:, postrequire:, default_command:); end + def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end end end @@ -2196,9 +2255,6 @@ class Tapioca::Loaders::Loader abstract! - # source://sorbet-runtime/0.5.10741/lib/types/private/abstract/declare.rb#37 - def initialize(*args, **_arg1, &blk); end - # @abstract # # source://tapioca//lib/tapioca/loaders/loader.rb#17 @@ -2207,61 +2263,69 @@ class Tapioca::Loaders::Loader private - # source://tapioca//lib/tapioca/loaders/loader.rb#182 + # source://tapioca//lib/tapioca/loaders/loader.rb#198 sig { void } def eager_load_rails_app; end # @return [Array] # - # source://tapioca//lib/tapioca/loaders/loader.rb#153 + # source://tapioca//lib/tapioca/loaders/loader.rb#169 def engines; end - # source://tapioca//lib/tapioca/loaders/loader.rb#24 + # source://tapioca//lib/tapioca/loaders/loader.rb#29 sig do params( gemfile: ::Tapioca::Gemfile, initialize_file: T.nilable(::String), - require_file: T.nilable(::String) + require_file: T.nilable(::String), + halt_upon_load_error: T::Boolean ).void end - def load_bundle(gemfile, initialize_file, require_file); end + def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error); end - # source://tapioca//lib/tapioca/loaders/loader.rb#111 + # source://tapioca//lib/tapioca/loaders/loader.rb#127 sig { void } def load_engines_in_classic_mode; end - # source://tapioca//lib/tapioca/loaders/loader.rb#89 + # source://tapioca//lib/tapioca/loaders/loader.rb#105 sig { void } def load_engines_in_zeitwerk_mode; end - # source://tapioca//lib/tapioca/loaders/loader.rb#37 - sig { params(environment_load: T::Boolean, eager_load: T::Boolean, app_root: ::String).void } - def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil), app_root: T.unsafe(nil)); end + # source://tapioca//lib/tapioca/loaders/loader.rb#49 + sig do + params( + environment_load: T::Boolean, + eager_load: T::Boolean, + app_root: ::String, + halt_upon_load_error: T::Boolean + ).void + end + def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end - # source://tapioca//lib/tapioca/loaders/loader.rb#64 + # source://tapioca//lib/tapioca/loaders/loader.rb#80 sig { void } def load_rails_engines; end - # source://tapioca//lib/tapioca/loaders/loader.rb#203 + # source://tapioca//lib/tapioca/loaders/loader.rb#219 sig { params(file: T.nilable(::String)).void } def require_helper(file); end - # source://tapioca//lib/tapioca/loaders/loader.rb#78 + # source://tapioca//lib/tapioca/loaders/loader.rb#94 def run_initializers; end - # source://tapioca//lib/tapioca/loaders/loader.rb#167 + # source://tapioca//lib/tapioca/loaders/loader.rb#183 sig { params(path: ::String).void } def safe_require(path); end - # source://tapioca//lib/tapioca/loaders/loader.rb#174 + # source://tapioca//lib/tapioca/loaders/loader.rb#190 sig { void } def silence_deprecations; end - # source://tapioca//lib/tapioca/loaders/loader.rb#136 + # source://tapioca//lib/tapioca/loaders/loader.rb#152 sig { params(blk: T.proc.void).void } def with_rails_application(&blk); end - # source://tapioca//lib/tapioca/loaders/loader.rb#129 + # source://tapioca//lib/tapioca/loaders/loader.rb#145 sig { returns(T::Boolean) } def zeitwerk_mode?; end end @@ -2301,7 +2365,7 @@ module Tapioca::RBIFilesHelper dsl_dir: ::String, auto_strictness: T::Boolean, gems: T::Array[::Tapioca::Gemfile::GemSpec], - compilers: T::Enumerable[::Class] + compilers: T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)] ).void end def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: T.unsafe(nil), compilers: T.unsafe(nil)); end @@ -2472,7 +2536,7 @@ module Tapioca::Runtime; end # available, it implements finding the attached class of a singleton # class by iterating through ObjectSpace. module Tapioca::Runtime::AttachedClassOf - # source://tapioca//lib/tapioca/runtime/attached_class_of_legacy.rb#17 + # source://tapioca//lib/tapioca/runtime/attached_class_of_32.rb#14 sig { params(singleton_class: ::Class).returns(T.nilable(::Module)) } def attached_class_of(singleton_class); end end @@ -2610,7 +2674,7 @@ module Tapioca::Runtime::GenericTypeRegistry def create_generic_type(constant, name); end # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#155 - sig { params(constant: ::Class).returns(::Class) } + sig { params(constant: T::Class[T.anything]).returns(T::Class[T.anything]) } def create_safe_subclass(constant); end # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#182 @@ -2635,6 +2699,10 @@ module Tapioca::Runtime::Reflection extend ::Tapioca::Runtime::AttachedClassOf extend ::Tapioca::Runtime::Reflection + # source://tapioca//lib/tapioca/runtime/reflection.rb#196 + sig { params(constant: ::Module).returns(T.untyped) } + def abstract_type_of(constant); end + # source://tapioca//lib/tapioca/runtime/reflection.rb#77 sig { params(constant: ::Module).returns(T::Array[::Module]) } def ancestors_of(constant); end @@ -2644,7 +2712,7 @@ module Tapioca::Runtime::Reflection def are_equal?(object, other); end # source://tapioca//lib/tapioca/runtime/reflection.rb#56 - sig { params(object: ::BasicObject).returns(::Class) } + sig { params(object: ::BasicObject).returns(T::Class[T.anything]) } def class_of(object); end # @param constant [BasicObject] @@ -2679,7 +2747,7 @@ module Tapioca::Runtime::Reflection sig do type_parameters(:U) .params( - klass: T.all(::Class, T.type_parameter(:U)) + klass: T.all(T.type_parameter(:U), T::Class[T.anything]) ).returns(T::Array[T.type_parameter(:U)]) end def descendants_of(klass); end @@ -2688,6 +2756,10 @@ module Tapioca::Runtime::Reflection sig { params(constant: ::Module).returns(T::Set[::String]) } def file_candidates_for(constant); end + # source://tapioca//lib/tapioca/runtime/reflection.rb#202 + sig { params(constant: ::Module).returns(T::Boolean) } + def final_module?(constant); end + # source://tapioca//lib/tapioca/runtime/reflection.rb#112 sig { params(constant: ::Module).returns(T::Array[::Module]) } def inherited_ancestors_of(constant); end @@ -2732,33 +2804,37 @@ module Tapioca::Runtime::Reflection sig { params(locations: T.nilable(T::Array[::Thread::Backtrace::Location])).returns(::String) } def resolve_loc(locations); end + # source://tapioca//lib/tapioca/runtime/reflection.rb#207 + sig { params(constant: ::Module).returns(T::Boolean) } + def sealed_module?(constant); end + # source://tapioca//lib/tapioca/runtime/reflection.rb#133 sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) } def signature_of(method); end # source://tapioca//lib/tapioca/runtime/reflection.rb#72 - sig { params(constant: ::Module).returns(::Class) } + sig { params(constant: ::Module).returns(T::Class[T.anything]) } def singleton_class_of(constant); end # source://tapioca//lib/tapioca/runtime/reflection.rb#82 - sig { params(constant: ::Class).returns(T.nilable(::Class)) } + sig { params(constant: T::Class[T.anything]).returns(T.nilable(T::Class[T.anything])) } def superclass_of(constant); end private - # source://tapioca//lib/tapioca/runtime/reflection.rb#228 + # source://tapioca//lib/tapioca/runtime/reflection.rb#244 sig { params(parent: ::Module, name: ::String).returns(T.nilable(::Module)) } def child_module_for_parent_with_name(parent, name); end - # source://tapioca//lib/tapioca/runtime/reflection.rb#239 + # source://tapioca//lib/tapioca/runtime/reflection.rb#255 sig { params(method: ::UnboundMethod).returns(T::Boolean) } def method_defined_by_forwardable_module?(method); end - # source://tapioca//lib/tapioca/runtime/reflection.rb#214 + # source://tapioca//lib/tapioca/runtime/reflection.rb#230 sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) } def methods_for(constant); end - # source://tapioca//lib/tapioca/runtime/reflection.rb#198 + # source://tapioca//lib/tapioca/runtime/reflection.rb#214 sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) } def relevant_methods_for(constant); end end @@ -2998,15 +3074,15 @@ Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String) # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#5 module Tapioca::SorbetHelper - # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#33 + # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#34 sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) } def sorbet(*sorbet_args); end - # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#38 + # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#39 sig { returns(::String) } def sorbet_path; end - # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#45 + # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#46 sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) } def sorbet_supports?(feature, version: T.unsafe(nil)); end end @@ -3088,7 +3164,7 @@ module Tapioca::Static::SymbolLoader # @return [Array] # - # source://sorbet-runtime/0.5.10741/lib/types/private/methods/_methods.rb#255 + # source://sorbet-runtime/0.5.10908/lib/types/private/methods/_methods.rb#255 def engines(*args, **_arg1, &blk); end # source://tapioca//lib/tapioca/static/symbol_loader.rb#73 @@ -3131,16 +3207,16 @@ Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String) # source://tapioca//lib/tapioca.rb#34 Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String) -# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#122 +# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#137 class Tapioca::TypeVariable < ::T::Types::TypeVariable # @return [TypeVariable] a new instance of TypeVariable # - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#123 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#138 def initialize(name, variance); end # Returns the value of attribute name. # - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#128 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#143 def name; end end @@ -3150,9 +3226,9 @@ end # need to do any matching of constants to type variables to bind their names, Ruby will # do that automatically for us and we get the `name` method for free from `Module`. # -# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#136 +# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#151 class Tapioca::TypeVariableModule < ::Module - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#158 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#177 sig do params( context: ::Module, @@ -3166,29 +3242,33 @@ class Tapioca::TypeVariableModule < ::Module end def initialize(context, type, variance, fixed, lower, upper, bounds_proc); end - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#212 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#231 sig { returns(::Tapioca::TypeVariable) } def coerce_to_type_variable; end - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#192 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#211 sig { returns(T::Boolean) } def fixed?; end - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#173 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#192 sig { returns(T.nilable(::String)) } def name; end - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#197 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#216 sig { returns(::String) } def serialize; end + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#163 + sig { returns(::Tapioca::TypeVariableModule::Type) } + def type; end + private - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#246 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#265 sig { returns(T::Hash[::Symbol, T.untyped]) } def bounds; end - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#222 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#241 sig do params( fixed: T.untyped, @@ -3198,7 +3278,7 @@ class Tapioca::TypeVariableModule < ::Module end def build_bounds_proc(fixed, lower, upper); end - # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#236 + # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#255 sig do type_parameters(:Result) .params( @@ -3208,11 +3288,12 @@ class Tapioca::TypeVariableModule < ::Module def with_bound_name_pre_3_0(&block); end end -# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#139 +# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#154 class Tapioca::TypeVariableModule::Type < ::T::Enum enums do Member = new Template = new + HasAttachedClass = new end end @@ -3230,14 +3311,14 @@ class URI::Source < ::URI::File sig { params(v: T.nilable(::String)).returns(T::Boolean) } def check_host(v); end - # source://uri/0.11.0/uri/generic.rb#243 + # source://uri/0.12.1/uri/generic.rb#243 def gem_name; end # source://tapioca//lib/tapioca/helpers/source_uri.rb#25 sig { returns(T.nilable(::String)) } def gem_version; end - # source://uri/0.11.0/uri/generic.rb#283 + # source://uri/0.12.1/uri/generic.rb#283 def line_number; end # source://tapioca//lib/tapioca/helpers/source_uri.rb#51 @@ -3264,3 +3345,5 @@ end # source://tapioca//lib/tapioca/helpers/source_uri.rb#10 URI::Source::COMPONENT = T.let(T.unsafe(nil), Array) + +class URI::WSS < ::URI::WS; end diff --git a/sorbet/rbi/gems/thor@1.2.1.rbi b/sorbet/rbi/gems/thor@1.2.2.rbi similarity index 97% rename from sorbet/rbi/gems/thor@1.2.1.rbi rename to sorbet/rbi/gems/thor@1.2.2.rbi index 604c1f70..dcb11ee2 100644 --- a/sorbet/rbi/gems/thor@1.2.1.rbi +++ b/sorbet/rbi/gems/thor@1.2.2.rbi @@ -693,7 +693,7 @@ module Thor::Actions # flag:: the regexp or string to be replaced # replacement:: the replacement, can be also given as a block # config:: give :verbose => false to not log the status, and - # :force => true, to force the replacement regardles of runner behavior. + # :force => true, to force the replacement regardless of runner behavior. # # ==== Example # @@ -871,7 +871,7 @@ module Thor::Actions # run('ln -s ~/edge rails') # end # - # source://thor//lib/thor/actions.rb#248 + # source://thor//lib/thor/actions.rb#249 def run(command, config = T.unsafe(nil)); end # Executes a ruby script (taking into account WIN32 platform quirks). @@ -880,7 +880,7 @@ module Thor::Actions # command:: the command to be executed. # config:: give :verbose => false to not log the status. # - # source://thor//lib/thor/actions.rb#285 + # source://thor//lib/thor/actions.rb#286 def run_ruby_script(command, config = T.unsafe(nil)); end # Holds source paths in instance so they can be manipulated. @@ -924,7 +924,7 @@ module Thor::Actions # thor :list, :all => true, :substring => 'rails' # #=> thor list --all --substring=rails # - # source://thor//lib/thor/actions.rb#308 + # source://thor//lib/thor/actions.rb#309 def thor(command, *args); end # Uncomment all lines matching a given regex. It will leave the space @@ -945,12 +945,12 @@ module Thor::Actions protected - # source://thor//lib/thor/actions.rb#329 + # source://thor//lib/thor/actions.rb#330 def _cleanup_options_and_set(options, key); end # Allow current root to be shared between invocations. # - # source://thor//lib/thor/actions.rb#325 + # source://thor//lib/thor/actions.rb#326 def _shared_configuration; end private @@ -1297,10 +1297,10 @@ end # source://thor//lib/thor/actions/inject_into_file.rb#24 Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash) -# source://thor//lib/thor/error.rb#60 +# source://thor//lib/thor/error.rb#68 class Thor::AmbiguousCommandError < ::Thor::Error; end -# source://thor//lib/thor/error.rb#62 +# source://thor//lib/thor/error.rb#70 Thor::AmbiguousTaskError = Thor::AmbiguousCommandError # source://thor//lib/thor/parser/argument.rb#2 @@ -1982,12 +1982,12 @@ module Thor::Base::ClassMethods # SIGNATURE: Sets the baseclass. This is where the superclass lookup # finishes. # - # source://thor//lib/thor/base.rb#679 + # source://thor//lib/thor/base.rb#678 def baseclass; end # The basename of the program invoking the thor class. # - # source://thor//lib/thor/base.rb#673 + # source://thor//lib/thor/base.rb#672 def basename; end # Build an option and adds it to the given scope. @@ -1997,7 +1997,7 @@ module Thor::Base::ClassMethods # options:: Described in both class_option and method_option. # scope:: Options hash that is being built up # - # source://thor//lib/thor/base.rb#590 + # source://thor//lib/thor/base.rb#589 def build_option(name, options, scope); end # Receives a hash of options, parse them and add to the scope. This is a @@ -2008,7 +2008,7 @@ module Thor::Base::ClassMethods # ==== Parameters # Hash[Symbol => Object] # - # source://thor//lib/thor/base.rb#601 + # source://thor//lib/thor/base.rb#600 def build_options(options, scope); end # Prints the class options per group. If an option does not belong to @@ -2020,65 +2020,65 @@ module Thor::Base::ClassMethods # SIGNATURE: Creates a new command if valid_command? is true. This method is # called when a new method is added to the class. # - # source://thor//lib/thor/base.rb#684 + # source://thor//lib/thor/base.rb#683 def create_command(meth); end # SIGNATURE: Creates a new command if valid_command? is true. This method is # called when a new method is added to the class. # - # source://thor//lib/thor/base.rb#684 + # source://thor//lib/thor/base.rb#683 def create_task(meth); end # SIGNATURE: The hook invoked by start. # # @raise [NotImplementedError] # - # source://thor//lib/thor/base.rb#694 + # source://thor//lib/thor/base.rb#693 def dispatch(command, given_args, given_opts, config); end # Finds a command with the given name. If the command belongs to the current # class, just return it, otherwise dup it and add the fresh copy to the # current command hash. # - # source://thor//lib/thor/base.rb#610 + # source://thor//lib/thor/base.rb#609 def find_and_refresh_command(name); end # Finds a command with the given name. If the command belongs to the current # class, just return it, otherwise dup it and add the fresh copy to the # current command hash. # - # source://thor//lib/thor/base.rb#610 + # source://thor//lib/thor/base.rb#609 def find_and_refresh_task(name); end # Retrieves a value from superclass. If it reaches the baseclass, # returns default. # - # source://thor//lib/thor/base.rb#651 + # source://thor//lib/thor/base.rb#650 def from_superclass(method, default = T.unsafe(nil)); end - # Everytime someone inherits from a Thor class, register the klass + # Every time someone inherits from a Thor class, register the klass # and file into baseclass. # - # source://thor//lib/thor/base.rb#623 + # source://thor//lib/thor/base.rb#622 def inherited(klass); end # SIGNATURE: Defines behavior when the initialize method is added to the # class. # - # source://thor//lib/thor/base.rb#690 + # source://thor//lib/thor/base.rb#689 def initialize_added; end # Raises an error if the word given is a Thor reserved word. # # @return [Boolean] # - # source://thor//lib/thor/base.rb#579 + # source://thor//lib/thor/base.rb#578 def is_thor_reserved_word?(word, type); end # Fire this callback whenever a method is added. Added methods are # tracked as commands by invoking the create_command method. # - # source://thor//lib/thor/base.rb#631 + # source://thor//lib/thor/base.rb#630 def method_added(meth); end # Receives a set of options and print them. @@ -2241,8 +2241,14 @@ class Thor::CoreExt::HashWithIndifferentAccess < ::Hash def method_missing(method, *args); end end -# source://thor//lib/thor/error.rb#2 -Thor::Correctable = DidYouMean::Correctable +# source://thor//lib/thor/error.rb#14 +module Thor::Correctable + # source://thor//lib/thor/error.rb#19 + def corrections; end + + # source://thor//lib/thor/error.rb#15 + def to_s; end +end # A dynamic command that handles method missing scenarios. # @@ -2267,7 +2273,7 @@ Thor::DynamicTask = Thor::DynamicCommand # overwrites a thor keyword, SHOULD NOT raise a Thor::Error. This way, we # ensure that developer errors are shown with full backtrace. # -# source://thor//lib/thor/error.rb#23 +# source://thor//lib/thor/error.rb#31 class Thor::Error < ::StandardError; end # Thor has a special class called Thor::Group. The main difference to Thor class @@ -2605,7 +2611,7 @@ end # Raised when a command was found, but not invoked properly. # -# source://thor//lib/thor/error.rb#65 +# source://thor//lib/thor/error.rb#73 class Thor::InvocationError < ::Thor::Error; end # source://thor//lib/thor/line_editor/basic.rb#2 @@ -2718,7 +2724,7 @@ class Thor::LineEditor::Readline::PathCompletion def text; end end -# source://thor//lib/thor/error.rb#101 +# source://thor//lib/thor/error.rb#109 class Thor::MalformattedArgumentError < ::Thor::InvocationError; end # source://thor//lib/thor/nested_context.rb#2 @@ -2763,10 +2769,13 @@ class Thor::Option < ::Thor::Argument # source://thor//lib/thor/parser/option.rb#3 def aliases; end - # source://thor//lib/thor/parser/option.rb#105 + # source://thor//lib/thor/parser/option.rb#99 + def aliases_for_usage; end + + # source://thor//lib/thor/parser/option.rb#109 def array?; end - # source://thor//lib/thor/parser/option.rb#105 + # source://thor//lib/thor/parser/option.rb#109 def boolean?; end # Returns the value of attribute group. @@ -2774,7 +2783,7 @@ class Thor::Option < ::Thor::Argument # source://thor//lib/thor/parser/option.rb#3 def group; end - # source://thor//lib/thor/parser/option.rb#105 + # source://thor//lib/thor/parser/option.rb#109 def hash?; end # Returns the value of attribute hide. @@ -2790,7 +2799,7 @@ class Thor::Option < ::Thor::Argument # source://thor//lib/thor/parser/option.rb#3 def lazy_default; end - # source://thor//lib/thor/parser/option.rb#105 + # source://thor//lib/thor/parser/option.rb#109 def numeric?; end # Returns the value of attribute repeatable. @@ -2798,7 +2807,7 @@ class Thor::Option < ::Thor::Argument # source://thor//lib/thor/parser/option.rb#3 def repeatable; end - # source://thor//lib/thor/parser/option.rb#105 + # source://thor//lib/thor/parser/option.rb#109 def string?; end # source://thor//lib/thor/parser/option.rb#75 @@ -2809,23 +2818,23 @@ class Thor::Option < ::Thor::Argument protected - # source://thor//lib/thor/parser/option.rb#155 + # source://thor//lib/thor/parser/option.rb#159 def dasherize(str); end # @return [Boolean] # - # source://thor//lib/thor/parser/option.rb#147 + # source://thor//lib/thor/parser/option.rb#151 def dasherized?; end - # source://thor//lib/thor/parser/option.rb#151 + # source://thor//lib/thor/parser/option.rb#155 def undasherize(str); end # @raise [ArgumentError] # - # source://thor//lib/thor/parser/option.rb#113 + # source://thor//lib/thor/parser/option.rb#117 def validate!; end - # source://thor//lib/thor/parser/option.rb#118 + # source://thor//lib/thor/parser/option.rb#122 def validate_default_type!; end class << self @@ -3010,7 +3019,7 @@ module Thor::RakeCompat end end -# source://thor//lib/thor/error.rb#98 +# source://thor//lib/thor/error.rb#106 class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end # source://thor//lib/thor/util.rb#4 @@ -3366,7 +3375,7 @@ Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) # Inherit from Thor::Shell::Basic and add set_color behavior. Check # Thor::Shell::Basic to see all available methods. # -# source://thor//lib/thor/shell/color.rb#9 +# source://thor//lib/thor/shell/color.rb#8 class Thor::Shell::Color < ::Thor::Shell::Basic # Set color by using a string or one of the defined constants. If a third # option is set to true, it also adds bold to the string. This is based @@ -3531,7 +3540,7 @@ Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String) # Inherit from Thor::Shell::Basic and add set_color behavior. Check # Thor::Shell::Basic to see all available methods. # -# source://thor//lib/thor/shell/html.rb#9 +# source://thor//lib/thor/shell/html.rb#8 class Thor::Shell::HTML < ::Thor::Shell::Basic # Ask something to the user and receives a response. # @@ -3679,84 +3688,84 @@ Thor::Task = Thor::Command # Raised when a command was not found. # -# source://thor//lib/thor/error.rb#27 +# source://thor//lib/thor/error.rb#35 class Thor::UndefinedCommandError < ::Thor::Error - include ::DidYouMean::Correctable + include ::Thor::Correctable # @return [UndefinedCommandError] a new instance of UndefinedCommandError # - # source://thor//lib/thor/error.rb#46 + # source://thor//lib/thor/error.rb#54 def initialize(command, all_commands, namespace); end # Returns the value of attribute all_commands. # - # source://thor//lib/thor/error.rb#44 + # source://thor//lib/thor/error.rb#52 def all_commands; end # Returns the value of attribute command. # - # source://thor//lib/thor/error.rb#44 + # source://thor//lib/thor/error.rb#52 def command; end end -# source://thor//lib/thor/error.rb#28 +# source://thor//lib/thor/error.rb#36 class Thor::UndefinedCommandError::SpellChecker # @return [SpellChecker] a new instance of SpellChecker # - # source://thor//lib/thor/error.rb#31 + # source://thor//lib/thor/error.rb#39 def initialize(error); end - # source://thor//lib/thor/error.rb#35 + # source://thor//lib/thor/error.rb#43 def corrections; end # Returns the value of attribute error. # - # source://thor//lib/thor/error.rb#29 + # source://thor//lib/thor/error.rb#37 def error; end - # source://thor//lib/thor/error.rb#39 + # source://thor//lib/thor/error.rb#47 def spell_checker; end end -# source://thor//lib/thor/error.rb#58 +# source://thor//lib/thor/error.rb#66 Thor::UndefinedTaskError = Thor::UndefinedCommandError -# source://thor//lib/thor/error.rb#68 +# source://thor//lib/thor/error.rb#76 class Thor::UnknownArgumentError < ::Thor::Error - include ::DidYouMean::Correctable + include ::Thor::Correctable # @return [UnknownArgumentError] a new instance of UnknownArgumentError # - # source://thor//lib/thor/error.rb#88 + # source://thor//lib/thor/error.rb#96 def initialize(switches, unknown); end # Returns the value of attribute switches. # - # source://thor//lib/thor/error.rb#86 + # source://thor//lib/thor/error.rb#94 def switches; end # Returns the value of attribute unknown. # - # source://thor//lib/thor/error.rb#86 + # source://thor//lib/thor/error.rb#94 def unknown; end end -# source://thor//lib/thor/error.rb#69 +# source://thor//lib/thor/error.rb#77 class Thor::UnknownArgumentError::SpellChecker # @return [SpellChecker] a new instance of SpellChecker # - # source://thor//lib/thor/error.rb#72 + # source://thor//lib/thor/error.rb#80 def initialize(error); end - # source://thor//lib/thor/error.rb#76 + # source://thor//lib/thor/error.rb#84 def corrections; end # Returns the value of attribute error. # - # source://thor//lib/thor/error.rb#70 + # source://thor//lib/thor/error.rb#78 def error; end - # source://thor//lib/thor/error.rb#81 + # source://thor//lib/thor/error.rb#89 def spell_checker; end end diff --git a/sorbet/rbi/gems/unparser@0.6.7.rbi b/sorbet/rbi/gems/unparser@0.6.7.rbi deleted file mode 100644 index 6e87a2ea..00000000 --- a/sorbet/rbi/gems/unparser@0.6.7.rbi +++ /dev/null @@ -1,4515 +0,0 @@ -# typed: true - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `unparser` gem. -# Please instead update this file by running `bin/tapioca gem unparser`. - -# Library namespace -# -# source://unparser//lib/unparser/equalizer.rb#3 -module Unparser - class << self - # Construct a parser buffer from string - # - # @param source [String] - # @return [Parser::Source::Buffer] - # - # source://unparser//lib/unparser.rb#147 - def buffer(source, identification = T.unsafe(nil)); end - - # Parse string into AST - # - # @param source [String] - # @return [Parser::AST::Node, nil] - # - # source://unparser//lib/unparser.rb#105 - def parse(source); end - - # Parse string into either syntax error or AST - # - # @param source [String] - # @return [Either] - # - # source://unparser//lib/unparser.rb#114 - def parse_either(source); end - - # Parse string into AST, with comments - # - # @param source [String] - # @return [Parser::AST::Node] - # - # source://unparser//lib/unparser.rb#125 - def parse_with_comments(source); end - - # Parser instance that produces AST unparser understands - # - # @api private - # @return [Parser::Base] - # - # source://unparser//lib/unparser.rb#134 - def parser; end - - # Unparse an AST (and, optionally, comments) into a string - # - # @api public - # @param node [Parser::AST::Node, nil] - # @param comment_array [Array] - # @raise InvalidNodeError - # if the node passed is invalid - # @return [String] - # - # source://unparser//lib/unparser.rb#60 - def unparse(node, comment_array = T.unsafe(nil)); end - - # Unparse capturing errors - # - # This is mostly useful for writing testing tools against unparser. - # - # @param node [Parser::AST::Node, nil] - # @return [Either] - # - # source://unparser//lib/unparser.rb#96 - def unparse_either(node); end - - # Unparse with validation - # - # @param node [Parser::AST::Node, nil] - # @param comment_array [Array] - # @return [Either] - # - # source://unparser//lib/unparser.rb#78 - def unparse_validate(node, comment_array = T.unsafe(nil)); end - end -end - -# Namespace for AST processing tools -# -# source://unparser//lib/unparser/ast.rb#5 -module Unparser::AST - class << self - # Return local variables that get assigned in scope - # - # @api private - # @param node [Parser::AST::Node] - # @return [Set] - # - # source://unparser//lib/unparser/ast.rb#57 - def local_variable_assignments(node); end - - # Return local variables read - # - # @api private - # @param node [Parser::AST::Node] - # @return [Set] - # - # source://unparser//lib/unparser/ast.rb#72 - def local_variable_reads(node); end - - # Test for local variable inherited scope reset - # - # @api private - # @param node [Parser::AST::Node] - # @return [Boolean] - # - # source://unparser//lib/unparser/ast.rb#33 - def not_close_scope?(node); end - - # Test for local variable scope reset - # - # @api private - # @param node [Parser::AST::Node] - # @return [Boolean] - # - # source://unparser//lib/unparser/ast.rb#45 - def not_reset_scope?(node); end - end -end - -# Nodes that assign a local variable -# -# source://unparser//lib/unparser/ast.rb#14 -Unparser::AST::ASSIGN_NODES = T.let(T.unsafe(nil), Set) - -# source://unparser//lib/unparser/ast.rb#11 -Unparser::AST::CLOSE_NODES = T.let(T.unsafe(nil), Array) - -# AST enumerator -# -# source://unparser//lib/unparser/ast.rb#80 -class Unparser::AST::Enumerator - include ::Enumerable - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # Return each node - # - # @api private - # @return [Enumerator] if no block given - # @return [self] otherwise - # - # source://unparser//lib/unparser/ast.rb#106 - def each(&block); end - - # Return nodes selected by type - # - # @api private - # @param type [Symbol] - # @return [Enumerable] - # - # source://unparser//lib/unparser/ast.rb#130 - def type(type); end - - # Return nodes selected by types - # - # @api private - # @param types [Enumerable] - # @return [Enumerable] - # - # source://unparser//lib/unparser/ast.rb#118 - def types(types); end - - class << self - # Return new instance - # - # @api private - # @param node [Parser::AST::Node] - # @param controller [#call(node)] - # @return [Enumerator] - # - # source://unparser//lib/unparser/ast.rb#92 - def new(node, controller = T.unsafe(nil)); end - - private - - # Return frozne set of objects - # - # @api private - # @param enumerable [Enumerable] - # @return [Set] - # - # source://unparser//lib/unparser/ast.rb#142 - def set(enumerable); end - - # Return nodes of type - # - # @api private - # @param node [Parser::AST::Node] - # @param type [Symbol] - # @return [Enumerable>] ] - # otherwise - # - # source://unparser//lib/unparser/ast/local_variable_scope.rb#121 - def each(node, &block); end - - private - - # source://unparser//lib/unparser/ast/local_variable_scope.rb#127 - def current; end - - # source://unparser//lib/unparser/ast/local_variable_scope.rb#156 - def define(name); end - - # source://unparser//lib/unparser/ast/local_variable_scope.rb#141 - def enter(node); end - - # source://unparser//lib/unparser/ast/local_variable_scope.rb#152 - def leave(node); end - - # source://unparser//lib/unparser/ast/local_variable_scope.rb#168 - def pop; end - - # source://unparser//lib/unparser/ast/local_variable_scope.rb#164 - def push_inherit; end - - # source://unparser//lib/unparser/ast/local_variable_scope.rb#160 - def push_reset; end - - # @yield [node, current.dup, before] - # - # source://unparser//lib/unparser/ast/local_variable_scope.rb#131 - def visit(node, &block); end - - class << self - # Enumerate each node with its local variable scope - # - # @api private - # @param node [Parser::AST::Node] - # @return [self] - # - # source://unparser//lib/unparser/ast/local_variable_scope.rb#106 - def each(node, &block); end - end -end - -# source://unparser//lib/unparser/ast.rb#9 -Unparser::AST::RESET_NODES = T.let(T.unsafe(nil), Array) - -# source://unparser//lib/unparser/ast.rb#7 -Unparser::AST::TAUTOLOGY = T.let(T.unsafe(nil), Proc) - -# Controlled AST walker walking the AST in deeth first search with pre order -# -# source://unparser//lib/unparser/ast.rb#164 -class Unparser::AST::Walker - include ::Unparser::Equalizer::Methods - - # Call walker with node - # - # @api private - # @param node [Parser::AST::Node] - # @return [undefined] - # - # source://unparser//lib/unparser/ast.rb#188 - def call(node); end - - class << self - # Call ast walker - # - # @api private - # @param node [Parser::AST::Node] - # @return [self] - # - # source://unparser//lib/unparser/ast.rb#175 - def call(node, controller = T.unsafe(nil), &block); end - end -end - -# Module to allow class and methods to be abstract -# -# Original code before vendoring and reduction from: https://github.com/dkubb/abstract_type. -# -# source://unparser//lib/unparser/abstract_type.rb#7 -module Unparser::AbstractType - mixes_in_class_methods ::Unparser::AbstractType::AbstractMethodDeclarations - - class << self - private - - # Define the new method on the abstract type - # - # Ensures that the instance cannot be of the abstract type - # and must be a descendant. - # - # @api private - # @param abstract_class [Class] - # @return [undefined] - # - # source://unparser//lib/unparser/abstract_type.rb#35 - def create_new_method(abstract_class); end - - # Hook called when module is included - # - # @api private - # @param descendant [Module] the module or class including AbstractType - # @return [undefined] - # - # source://unparser//lib/unparser/abstract_type.rb#17 - def included(descendant); end - end -end - -# source://unparser//lib/unparser/abstract_type.rb#47 -module Unparser::AbstractType::AbstractMethodDeclarations - # Create abstract instance methods - # - # @api public - # @example - # class Foo - # include AbstractType - # - # # Create an abstract instance method - # abstract_method :some_method - # end - # @param names [Array<#to_s>] - # @return [self] - # - # source://unparser//lib/unparser/abstract_type.rb#64 - def abstract_method(*names); end - - # Create abstract singleton methods - # - # @api private - # @example - # class Foo - # include AbstractType - # - # # Create an abstract instance method - # abstract_singleton_method :some_method - # end - # @param names [Array<#to_s>] - # @return [self] - # - # source://unparser//lib/unparser/abstract_type.rb#84 - def abstract_singleton_method(*names); end - - private - - # Create abstract instance method - # - # @api private - # @param name [#to_s] the name of the method to create - # @return [undefined] - # - # source://unparser//lib/unparser/abstract_type.rb#113 - def create_abstract_instance_method(name); end - - # Create abstract singleton method - # - # @api private - # @param name [#to_s] the name of the method to create - # @return [undefined] - # - # source://unparser//lib/unparser/abstract_type.rb#99 - def create_abstract_singleton_method(name); end -end - -# Allows objects to be made immutable -# -# Original code before vendoring and reduction from: https://github.com/dkubb/adamantium. -# -# source://unparser//lib/unparser/adamantium.rb#7 -module Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - - mixes_in_class_methods ::Unparser::Adamantium::ModuleMethods - mixes_in_class_methods ::Unparser::Adamantium::ClassMethods - - class << self - private - - # ModuleMethods - # - # source://unparser//lib/unparser/adamantium.rb#141 - def included(descendant); end - end -end - -# Methods mixed in to adamantium classes -# -# source://unparser//lib/unparser/adamantium.rb#70 -module Unparser::Adamantium::ClassMethods - # Instantiate a new frozen object - # - # @api public - # @return [Object] - # - # source://unparser//lib/unparser/adamantium.rb#77 - def new(*_arg0); end -end - -# source://unparser//lib/unparser/adamantium.rb#8 -module Unparser::Adamantium::InstanceMethods - # A noop #dup for immutable objects - # - # @api public - # @return [self] - # - # source://unparser//lib/unparser/adamantium.rb#14 - def dup; end - - # Freeze the object - # - # @api public - # @return [Object] - # - # source://unparser//lib/unparser/adamantium.rb#23 - def freeze; end - - private - - # source://unparser//lib/unparser/adamantium.rb#30 - def memoized_method_cache; end -end - -# Storage for memoized methods -# -# source://unparser//lib/unparser/adamantium.rb#37 -class Unparser::Adamantium::Memory - # Initialize the memory storage for memoized methods - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/adamantium.rb#44 - def initialize(values); end - - # Fetch the value from memory, or evaluate if it does not exist - # - # @api public - # @param name [Symbol] - # @yieldreturn [Object] the value to memoize - # - # source://unparser//lib/unparser/adamantium.rb#58 - def fetch(name); end -end - -# Build the memoized method -# -# source://unparser//lib/unparser/adamantium/method_builder.rb#6 -class Unparser::Adamantium::MethodBuilder - # Initialize an object to build a memoized method - # - # @api private - # @param descendant [Module] - # @param method_name [Symbol] - # @return [undefined] - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#47 - def initialize(descendant, method_name); end - - # Build a new memoized method - # - # @api public - # @example - # method_builder.call # => creates new method - # @return [UnboundMethod] - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#63 - def call; end - - private - - # source://unparser//lib/unparser/adamantium/method_builder.rb#72 - def assert_arity(arity); end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#83 - def create_memoized_method; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#78 - def remove_original_method; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#97 - def set_method_visibility; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#101 - def visibility; end -end - -# Raised when a block is passed to a memoized method -# -# source://unparser//lib/unparser/adamantium/method_builder.rb#25 -class Unparser::Adamantium::MethodBuilder::BlockNotAllowedError < ::ArgumentError - # Initialize a block not allowed exception - # - # @api private - # @param descendant [Module] - # @param method [Symbol] - # @return [BlockNotAllowedError] a new instance of BlockNotAllowedError - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#33 - def initialize(descendant, method); end -end - -# Raised when the method arity is invalid -# -# source://unparser//lib/unparser/adamantium/method_builder.rb#9 -class Unparser::Adamantium::MethodBuilder::InvalidArityError < ::ArgumentError - # Initialize an invalid arity exception - # - # @api private - # @param descendant [Module] - # @param method [Symbol] - # @param arity [Integer] - # @return [InvalidArityError] a new instance of InvalidArityError - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#18 - def initialize(descendant, method, arity); end -end - -# Methods mixed in to adamantium modules -# -# source://unparser//lib/unparser/adamantium.rb#84 -module Unparser::Adamantium::ModuleMethods - # Memoize a list of methods - # - # @api public - # @param methods [Array<#to_s>] a list of methods to memoize - # @return [self] - # - # source://unparser//lib/unparser/adamantium.rb#94 - def memoize(*methods); end - - # Test if method is memoized - # - # @param name [Symbol] - # @return [Bool] - # - # source://unparser//lib/unparser/adamantium.rb#104 - def memoized?(method_name); end - - # Return unmemoized instance method - # - # @api public - # @param name [Symbol] - # @raise [NameError] raised if the method is unknown - # @return [UnboundMethod] the memoized method - # - # source://unparser//lib/unparser/adamantium.rb#119 - def unmemoized_instance_method(method_name); end - - private - - # source://unparser//lib/unparser/adamantium.rb#127 - def memoize_method(method_name); end - - # source://unparser//lib/unparser/adamantium.rb#135 - def memoized_methods; end -end - -# Original code before vendoring and reduction from: https://github.com/mbj/anima. -# -# source://unparser//lib/unparser/anima.rb#5 -class Unparser::Anima < ::Module - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # Initialize object - # - # - # @return [undefined] - # - # source://unparser//lib/unparser/anima.rb#18 - def initialize(*names); end - - # Return new anima with attributes added - # - # @example - # anima = Anima.new(:foo) - # anima.add(:bar) # equals Anima.new(:foo, :bar) - # @return [Anima] - # - # source://unparser//lib/unparser/anima.rb#31 - def add(*names); end - - # Return attribute names - # - # @return [Enumerable] - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def attribute_names(&block); end - - # Return names - # - # @return [AttributeSet] - # - # source://unparser//lib/unparser/anima.rb#11 - def attributes; end - - # Return attributes hash for instance - # - # @param object [Object] - # @return [Hash] - # - # source://unparser//lib/unparser/anima.rb#52 - def attributes_hash(object); end - - # Initialize instance - # - # @param object [Object] - # @param attribute_hash [Hash] - # @return [self] - # - # source://unparser//lib/unparser/anima.rb#73 - def initialize_instance(object, attribute_hash); end - - # Return new anima with attributes removed - # - # @example - # anima = Anima.new(:foo, :bar) - # anima.remove(:bar) # equals Anima.new(:foo) - # @return [Anima] - # - # source://unparser//lib/unparser/anima.rb#43 - def remove(*names); end - - private - - # Fail unless keys in +attribute_hash+ matches #attribute_names - # - # @param klass [Class] the class being initialized - # @param attribute_hash [Hash] the attributes to initialize +object+ with - # @raise [Error] - # @return [undefined] - # - # source://unparser//lib/unparser/anima.rb#164 - def assert_known_attributes(klass, attribute_hash); end - - # Infect the instance with anima - # - # @param scope [Class, Module] - # @return [undefined] - # - # source://unparser//lib/unparser/anima.rb#137 - def included(descendant); end - - # Return new instance - # - # @param attributes [Enumerable] - # @return [Anima] - # - # source://unparser//lib/unparser/anima.rb#180 - def new(attributes); end -end - -# An attribute -# -# source://unparser//lib/unparser/anima/attribute.rb#6 -class Unparser::Anima::Attribute - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # Initialize attribute - # - # @param name [Symbol] - # @return [Attribute] a new instance of Attribute - # - # source://unparser//lib/unparser/anima/attribute.rb#12 - def initialize(name); end - - # Get attribute value from object - # - # @param object [Object] - # @return [Object] - # - # source://unparser//lib/unparser/anima/attribute.rb#42 - def get(object); end - - # Return instance variable name - # - # @return [Symbol] - # - # source://unparser//lib/unparser/anima/attribute.rb#25 - def instance_variable_name; end - - # Load attribute - # - # @param object [Object] - # @param attributes [Hash] - # @return [self] - # - # source://unparser//lib/unparser/anima/attribute.rb#33 - def load(object, attributes); end - - # Return attribute name - # - # @return [Symbol] - # - # source://unparser//lib/unparser/anima/attribute.rb#20 - def name; end - - # Set attribute value in object - # - # @param object [Object] - # @param value [Object] - # @return [self] - # - # source://unparser//lib/unparser/anima/attribute.rb#52 - def set(object, value); end -end - -# Abstract base class for anima errors -# -# source://unparser//lib/unparser/anima/error.rb#6 -class Unparser::Anima::Error < ::RuntimeError - # Initialize object - # - # @param klass [Class] the class being initialized - # @param missing [Enumerable] - # @param unknown [Enumerable] - # @return [undefined] - # - # source://unparser//lib/unparser/anima/error.rb#18 - def initialize(klass, missing, unknown); end -end - -# source://unparser//lib/unparser/anima/error.rb#7 -Unparser::Anima::Error::FORMAT = T.let(T.unsafe(nil), String) - -# Static instance methods for anima infected classes -# -# source://unparser//lib/unparser/anima.rb#82 -module Unparser::Anima::InstanceMethods - # Initialize an anima infected object - # - # - # @param attributes [#to_h] a hash that matches anima defined attributes - # @return [undefined] - # - # source://unparser//lib/unparser/anima.rb#91 - def initialize(attributes); end - - # Return a hash representation of an anima infected object - # - # @api public - # @example - # anima.to_h # => { :foo => : bar } - # @return [Hash] - # - # source://unparser//lib/unparser/anima.rb#104 - def to_h; end - - # Return updated instance - # - # @api public - # @example - # klass = Class.new do - # include Anima.new(:foo, :bar) - # end - # - # foo = klass.new(:foo => 1, :bar => 2) - # updated = foo.with(:foo => 3) - # updated.foo # => 3 - # updated.bar # => 2 - # @param attributes [Hash] - # @return [Anima] - # - # source://unparser//lib/unparser/anima.rb#125 - def with(attributes); end -end - -# Buffer used to emit into -# -# source://unparser//lib/unparser/buffer.rb#6 -class Unparser::Buffer - # Initialize object - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/buffer.rb#16 - def initialize; end - - # Append string - # - # @api private - # @param string [String] - # @return [self] - # - # source://unparser//lib/unparser/buffer.rb#29 - def append(string); end - - # Append a string without an indentation prefix - # - # @api private - # @param string [String] - # @return [self] - # - # source://unparser//lib/unparser/buffer.rb#45 - def append_without_prefix(string); end - - # Return content of buffer - # - # @api private - # @return [String] - # - # source://unparser//lib/unparser/buffer.rb#104 - def content; end - - # Test for a fresh line - # - # @api private - # @return [Boolean] - # - # source://unparser//lib/unparser/buffer.rb#94 - def fresh_line?; end - - # Increase indent - # - # @api private - # @return [self] - # - # source://unparser//lib/unparser/buffer.rb#55 - def indent; end - - # Write newline - # - # @api private - # @return [self] - # - # source://unparser//lib/unparser/buffer.rb#77 - def nl; end - - # source://unparser//lib/unparser/buffer.rb#81 - def root_indent; end - - # Decrease indent - # - # @api private - # @return [self] - # - # source://unparser//lib/unparser/buffer.rb#66 - def unindent; end - - # Write raw fragment to buffer - # - # Does not do indentation logic. - # - # @param fragment [String] - # @return [self] - # - # source://unparser//lib/unparser/buffer.rb#115 - def write(fragment); end - - private - - # source://unparser//lib/unparser/buffer.rb#124 - def prefix; end -end - -# source://unparser//lib/unparser/buffer.rb#122 -Unparser::Buffer::INDENT_SPACE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/buffer.rb#8 -Unparser::Buffer::NL = T.let(T.unsafe(nil), String) - -# Unparser specific AST builder defaulting to modern AST format -# -# source://unparser//lib/unparser.rb#23 -class Unparser::Builder < ::Parser::Builders::Default - # @return [Builder] a new instance of Builder - # - # source://unparser//lib/unparser.rb#26 - def initialize; end -end - -# Unparser CLI implementation -# -# source://unparser//lib/unparser/cli.rb#5 -class Unparser::CLI - # Initialize object - # - # @api private - # @param arguments [Array] - # @return [undefined] - # - # source://unparser//lib/unparser/cli.rb#74 - def initialize(arguments); end - - # Add options - # - # - # @api private - # @param builder [OptionParser] - # @return [undefined] - # - # source://unparser//lib/unparser/cli.rb#102 - def add_options(builder); end - - # Return exit status - # - # @api private - # @return [Integer] - # - # source://unparser//lib/unparser/cli.rb#132 - def exit_status; end - - private - - # source://unparser//lib/unparser/cli.rb#155 - def effective_targets; end - - # source://unparser//lib/unparser/cli.rb#143 - def process_target(target); end - - # source://unparser//lib/unparser/cli.rb#170 - def targets(file_name); end - - class << self - # Run CLI - # - # @api private - # @param arguments [Array] - # @return [Integer] the exit status - # - # source://unparser//lib/unparser/cli.rb#63 - def run(*arguments); end - end -end - -# source://unparser//lib/unparser/cli.rb#8 -Unparser::CLI::EXIT_FAILURE = T.let(T.unsafe(nil), Integer) - -# source://unparser//lib/unparser/cli.rb#7 -Unparser::CLI::EXIT_SUCCESS = T.let(T.unsafe(nil), Integer) - -# source://unparser//lib/unparser/cli.rb#10 -class Unparser::CLI::Target - include ::Unparser::AbstractType - extend ::Unparser::AbstractType::AbstractMethodDeclarations - - class << self - # source://unparser//lib/unparser/abstract_type.rb#36 - def new(*args, &block); end - end -end - -# Path target -# -# source://unparser//lib/unparser/cli.rb#14 -class Unparser::CLI::Target::Path < ::Unparser::CLI::Target - include ::Unparser::Equalizer::Methods - - # Literal for this target - # - # @return [Validation] - # - # source://unparser//lib/unparser/cli.rb#27 - def literal_validation; end - - # Validation for this target - # - # @return [Validation] - # - # source://unparser//lib/unparser/cli.rb#20 - def validation; end -end - -# String target -# -# source://unparser//lib/unparser/cli.rb#33 -class Unparser::CLI::Target::String - include ::Unparser::Equalizer::Methods - - # Literal for this target - # - # @return [Validation] - # - # source://unparser//lib/unparser/cli.rb#46 - def literal_validation; end - - # Validation for this target - # - # @return [Validation] - # - # source://unparser//lib/unparser/cli.rb#39 - def validation; end -end - -# Class to colorize strings -# -# source://unparser//lib/unparser/color.rb#5 -class Unparser::Color - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # Format text with color - # - # @param text [String] - # @return [String] - # - # source://unparser//lib/unparser/color.rb#13 - def format(text); end -end - -# source://unparser//lib/unparser/color.rb#39 -Unparser::Color::GREEN = T.let(T.unsafe(nil), Unparser::Color) - -# source://unparser//lib/unparser/color.rb#17 -Unparser::Color::NONE = T.let(T.unsafe(nil), T.untyped) - -# source://unparser//lib/unparser/color.rb#38 -Unparser::Color::RED = T.let(T.unsafe(nil), Unparser::Color) - -# Holds the comments that remain to be emitted -# -# source://unparser//lib/unparser/comments.rb#6 -class Unparser::Comments - # Initialize object - # - # @api private - # @param comments [Array] - # @return [undefined] - # - # source://unparser//lib/unparser/comments.rb#30 - def initialize(comments); end - - # Consume part or all of the node - # - # @api private - # @param node [Parser::AST::Node] - # @param source_part [Symbol] - # @return [undefined] - # - # source://unparser//lib/unparser/comments.rb#44 - def consume(node, source_part = T.unsafe(nil)); end - - # Proxy to singleton - # - # NOTICE: - # Delegating to stateless helpers is a pattern I saw many times in our code. - # Maybe we should make another helper module? include SingletonDelegator.new(:source_range) ? - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/comments.rb#18 - def source_range(*arguments); end - - # Take all remaining comments - # - # @api private - # @return [Array] - # - # source://unparser//lib/unparser/comments.rb#68 - def take_all; end - - # Take comments appear in the source before the specified part of the node - # - # @api private - # @param node [Parser::AST::Node] - # @param source_part [Symbol] - # @return [Array] - # - # source://unparser//lib/unparser/comments.rb#81 - def take_before(node, source_part); end - - # Take end-of-line comments - # - # @api private - # @return [Array] - # - # source://unparser//lib/unparser/comments.rb#55 - def take_eol_comments; end - - private - - # source://unparser//lib/unparser/comments.rb#119 - def take_up_to_line(line); end - - # source://unparser//lib/unparser/comments.rb#114 - def take_while; end - - # source://unparser//lib/unparser/comments.rb#123 - def unshift_documents(comments); end - - class << self - # Return source location part - # - # FIXME: This method should not be needed. It does to much inline signalling. - # - # :reek:ManualDispatch - # - # @api private - # @param node [Parser::AST::Node] - # @param part [Symbol] - # @return [Parser::Source::Range] if present - # @return [nil] otherwise - # - # source://unparser//lib/unparser/comments.rb#107 - def source_range(node, part); end - end -end - -# A mixin to define a composition -# -# Original code before vendoring and reduction from: https://github.com/mbj/concord. -# -# source://unparser//lib/unparser/concord.rb#7 -class Unparser::Concord < ::Module - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # Initialize object - # - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/concord.rb#30 - def initialize(*names); end - - # Return names - # - # @api private - # @return [Enumerable] - # - # source://unparser//lib/unparser/concord.rb#19 - def names; end - - private - - # Define equalizer - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/concord.rb#48 - def define_equalizer; end - - # Define initialize method - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/concord.rb#72 - def define_initialize; end - - # Define readers - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/concord.rb#58 - def define_readers; end - - # Return instance variable names - # - # @api private - # @return [String] - # - # source://unparser//lib/unparser/concord.rb#92 - def instance_variable_names; end -end - -# The maximum number of objects the hosting class is composed of -# -# source://unparser//lib/unparser/concord.rb#11 -Unparser::Concord::MAX_NR_OF_OBJECTS = T.let(T.unsafe(nil), Integer) - -# Mixin for public attribute readers -# -# source://unparser//lib/unparser/concord.rb#97 -class Unparser::Concord::Public < ::Unparser::Concord - # Hook called when module is included - # - # @api private - # @param descendant [Class, Module] - # @return [undefined] - # - # source://unparser//lib/unparser/concord.rb#107 - def included(descendant); end -end - -# All unparser constants maybe included in other libraries. -# -# source://unparser//lib/unparser/constants.rb#5 -module Unparser::Constants; end - -# All binary operators of the ruby language -# -# source://unparser//lib/unparser/constants.rb#13 -Unparser::Constants::BINARY_OPERATORS = T.let(T.unsafe(nil), Set) - -# source://unparser//lib/unparser/constants.rb#63 -Unparser::Constants::KEYWORDS = T.let(T.unsafe(nil), Set) - -# source://unparser//lib/unparser/constants.rb#45 -Unparser::Constants::K_ALIAS = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#44 -Unparser::Constants::K_AND = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#23 -Unparser::Constants::K_BEGIN = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#37 -Unparser::Constants::K_BREAK = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#24 -Unparser::Constants::K_CASE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#25 -Unparser::Constants::K_CLASS = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#21 -Unparser::Constants::K_DEF = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#28 -Unparser::Constants::K_DEFINE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#33 -Unparser::Constants::K_DEFINED = T.let(T.unsafe(nil), String) - -# Keywords -# -# source://unparser//lib/unparser/constants.rb#20 -Unparser::Constants::K_DO = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#59 -Unparser::Constants::K_EEND = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#46 -Unparser::Constants::K_ELSE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#47 -Unparser::Constants::K_ELSIF = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#58 -Unparser::Constants::K_ENCODING = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#22 -Unparser::Constants::K_END = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#27 -Unparser::Constants::K_ENSURE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#41 -Unparser::Constants::K_FALSE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#60 -Unparser::Constants::K_FILE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#48 -Unparser::Constants::K_FOR = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#43 -Unparser::Constants::K_IF = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#51 -Unparser::Constants::K_IN = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#29 -Unparser::Constants::K_MODULE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#40 -Unparser::Constants::K_NEXT = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#49 -Unparser::Constants::K_NIL = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#50 -Unparser::Constants::K_NOT = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#52 -Unparser::Constants::K_OR = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#35 -Unparser::Constants::K_POSTEXE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#34 -Unparser::Constants::K_PREEXE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#39 -Unparser::Constants::K_REDO = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#30 -Unparser::Constants::K_RESCUE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#38 -Unparser::Constants::K_RETRY = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#31 -Unparser::Constants::K_RETURN = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#26 -Unparser::Constants::K_SELF = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#36 -Unparser::Constants::K_SUPER = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#61 -Unparser::Constants::K_THEN = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#42 -Unparser::Constants::K_TRUE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#32 -Unparser::Constants::K_UNDEF = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#53 -Unparser::Constants::K_UNLESS = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#56 -Unparser::Constants::K_UNTIL = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#54 -Unparser::Constants::K_WHEN = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#55 -Unparser::Constants::K_WHILE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/constants.rb#57 -Unparser::Constants::K_YIELD = T.let(T.unsafe(nil), String) - -# All unary operators of the ruby language -# -# source://unparser//lib/unparser/constants.rb#8 -Unparser::Constants::UNARY_OPERATORS = T.let(T.unsafe(nil), Set) - -# DSL to help defining emitters -# -# source://unparser//lib/unparser/dsl.rb#5 -module Unparser::DSL - private - - # source://unparser//lib/unparser/dsl.rb#32 - def children(*names); end - - # source://unparser//lib/unparser/dsl.rb#17 - def define_child(name, index); end - - # source://unparser//lib/unparser/dsl.rb#24 - def define_group(name, range); end - - # source://unparser//lib/unparser/dsl.rb#9 - def define_remaining_children(names); end -end - -# Class to create diffs from source code -# -# source://unparser//lib/unparser/diff.rb#5 -class Unparser::Diff - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # Colorized unified source diff between old and new - # - # @return [String] if there is a diff - # @return [nil] otherwise - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def colorized_diff(&block); end - - # Unified source diff between old and new - # - # @return [String] if there is exactly one diff - # @return [nil] otherwise - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def diff(&block); end - - private - - # source://unparser//lib/unparser/diff.rb#62 - def diffs; end - - # source://unparser//lib/unparser/diff.rb#66 - def hunks; end - - # source://unparser//lib/unparser/diff.rb#81 - def max_length; end - - # source://unparser//lib/unparser/diff.rb#72 - def minimized_hunk; end - - class << self - # Build new object from source strings - # - # @param old [String] - # @param new [String] - # @return [Diff] - # - # source://unparser//lib/unparser/diff.rb#46 - def build(old, new); end - - private - - # source://unparser//lib/unparser/diff.rb#85 - def colorize_line(line); end - - # Break up source into lines - # - # @param source [String] - # @return [Array] - # - # source://unparser//lib/unparser/diff.rb#55 - def lines(source); end - end -end - -# source://unparser//lib/unparser/diff.rb#8 -Unparser::Diff::ADDITION = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/diff.rb#9 -Unparser::Diff::DELETION = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/diff.rb#10 -Unparser::Diff::NEWLINE = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser.rb#34 -Unparser::EMPTY_ARRAY = T.let(T.unsafe(nil), Array) - -# source://unparser//lib/unparser.rb#33 -Unparser::EMPTY_STRING = T.let(T.unsafe(nil), String) - -# RequireBLock -# -# source://unparser//lib/unparser/either.rb#21 -class Unparser::Either - include ::Unparser::RequireBlock - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # Test for left constructor - # - # @return [Boolean] - # - # source://unparser//lib/unparser/either.rb#42 - def left?; end - - # Test for right constructor - # - # @return [Boolean] - # - # source://unparser//lib/unparser/either.rb#49 - def right?; end - - class << self - # Execute block and wrap error in left - # - # @param exception [Class] - # @return [Either] - # - # source://unparser//lib/unparser/either.rb#33 - def wrap_error(*exceptions); end - end -end - -# source://unparser//lib/unparser/either.rb#56 -class Unparser::Either::Left < ::Unparser::Either - # Evaluate applicative block - # - # @return [Either::Left] - # - # source://unparser//lib/unparser/either.rb#64 - def bind(&block); end - - # Evaluate left side of branch - # - # @param left [#call] - # @param _right [#call] - # - # source://unparser//lib/unparser/either.rb#98 - def either(left, _right); end - - # Evaluate functor block - # - # @return [Either::Left] - # - # source://unparser//lib/unparser/either.rb#57 - def fmap(&block); end - - # Unwrap value from left - # - # @return [Object] - # - # source://unparser//lib/unparser/either.rb#71 - def from_left; end - - # Unwrap value from right - # - # @return [Object] - # - # source://unparser//lib/unparser/either.rb#79 - def from_right; end - - # Map over left value - # - # @return [Either::Right] - # - # source://unparser//lib/unparser/either.rb#90 - def lmap; end -end - -# Left -# -# source://unparser//lib/unparser/either.rb#106 -class Unparser::Either::Right < ::Unparser::Either - # Evaluate applicative block - # - # @return [Either] - # @yield [value] - # - # source://unparser//lib/unparser/either.rb#114 - def bind; end - - # Evaluate right side of branch - # - # @param _left [#call] - # @param right [#call] - # - # source://unparser//lib/unparser/either.rb#148 - def either(_left, right); end - - # Evaluate functor block - # - # @return [Either::Right] - # - # source://unparser//lib/unparser/either.rb#107 - def fmap; end - - # Unwrap value from left - # - # @return [Object] - # - # source://unparser//lib/unparser/either.rb#122 - def from_left; end - - # Unwrap value from right - # - # @return [Object] - # - # source://unparser//lib/unparser/either.rb#133 - def from_right; end - - # Map over left value - # - # @return [Either::Right] - # - # source://unparser//lib/unparser/either.rb#140 - def lmap(&block); end -end - -# Emitter base class -# -# source://unparser//lib/unparser/emitter.rb#7 -class Unparser::Emitter - include ::Unparser::NodeHelpers - include ::Unparser::Generation - include ::Unparser::Constants - include ::Unparser::AbstractType - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - extend ::Unparser::AbstractType::AbstractMethodDeclarations - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - extend ::Unparser::DSL - - # source://unparser//lib/unparser/anima.rb#146 - def buffer; end - - # source://unparser//lib/unparser/anima.rb#146 - def comments; end - - # Dispatch node write as statement - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/abstract_type.rb#114 - def dispatch(*_arg0); end - - # source://unparser//lib/unparser/emitter.rb#59 - def emit_mlhs; end - - # source://unparser//lib/unparser/anima.rb#146 - def local_variable_scope; end - - # source://unparser//lib/unparser/anima.rb#146 - def node; end - - # LocalVariableRoot - # - # source://unparser//lib/unparser/emitter.rb#38 - def node_type; end - - class << self - # source://unparser//lib/unparser/anima.rb#140 - def anima; end - - # Return emitter - # - # - # @api private - # @return [Emitter] - # - # source://unparser//lib/unparser/emitter.rb#70 - def emitter(buffer:, comments:, node:, local_variable_scope:); end - - # source://unparser//lib/unparser/abstract_type.rb#36 - def new(*args, &block); end - - private - - # Register emitter for type - # - # @api private - # @param types [Symbol] - # @return [undefined] - # - # source://unparser//lib/unparser/emitter.rb#50 - def handle(*types); end - end -end - -# Emitter for alias nodes -# -# source://unparser//lib/unparser/emitter/alias.rb#6 -class Unparser::Emitter::Alias < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/alias.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def source; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# Arguments emitter -# -# source://unparser//lib/unparser/emitter/args.rb#6 -class Unparser::Emitter::Args < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/args.rb#7 - def emit_block_arguments; end - - # source://unparser//lib/unparser/emitter/args.rb#15 - def emit_def_arguments; end - - # source://unparser//lib/unparser/emitter/args.rb#19 - def emit_lambda_arguments; end - - private - - # source://unparser//lib/unparser/emitter/args.rb#26 - def emit_shadowargs; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def normal_arguments(&block); end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def shadowargs(&block); end -end - -# Argument emitter -# -# source://unparser//lib/unparser/emitter/argument.rb#84 -class Unparser::Emitter::Argument < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#91 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Array literal emitter -# -# source://unparser//lib/unparser/emitter/array.rb#6 -class Unparser::Emitter::Array < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/array.rb#9 - def emit_heredoc_reminders; end - - private - - # source://unparser//lib/unparser/emitter/array.rb#15 - def dispatch; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def emitters(&block); end -end - -# Emitter for array patterns -# -# source://unparser//lib/unparser/emitter/array_pattern.rb#6 -class Unparser::Emitter::ArrayPattern < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/array_pattern.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/emitter/array_pattern.rb#20 - def emit_member(node); end -end - -# Base class for assignment emitters -# -# source://unparser//lib/unparser/emitter/assignment.rb#7 -class Unparser::Emitter::Assignment < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/assignment.rb#14 - def emit_heredoc_reminders; end - - # source://unparser//lib/unparser/abstract_type.rb#114 - def emit_left(*_arg0); end - - # source://unparser//lib/unparser/emitter/assignment.rb#10 - def symbol_name; end - - private - - # source://unparser//lib/unparser/emitter/assignment.rb#22 - def dispatch; end - - # source://unparser//lib/unparser/emitter/assignment.rb#27 - def emit_right; end -end - -# source://unparser//lib/unparser/emitter/assignment.rb#8 -Unparser::Emitter::Assignment::BINARY_OPERATOR = T.let(T.unsafe(nil), Array) - -# Constant assignment emitter -# -# source://unparser//lib/unparser/emitter/assignment.rb#57 -class Unparser::Emitter::Assignment::Constant < ::Unparser::Emitter::Assignment - private - - # source://unparser//lib/unparser/dsl.rb#18 - def base; end - - # source://unparser//lib/unparser/emitter/assignment.rb#65 - def emit_left; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def right; end -end - -# Variable assignment emitter -# -# source://unparser//lib/unparser/emitter/assignment.rb#42 -class Unparser::Emitter::Assignment::Variable < ::Unparser::Emitter::Assignment - private - - # source://unparser//lib/unparser/emitter/assignment.rb#50 - def emit_left; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def right; end -end - -# Emitter for begin nodes -# -# source://unparser//lib/unparser/emitter/begin.rb#7 -class Unparser::Emitter::Begin < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/begin.rb#11 - def emit_heredoc_reminders; end - - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/begin.rb#19 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Non send binary operator / keyword emitter -# -# source://unparser//lib/unparser/emitter/binary.rb#6 -class Unparser::Emitter::Binary < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/binary.rb#11 - def dispatch; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def writer(&block); end -end - -# Base class for and and or op-assign -# -# source://unparser//lib/unparser/emitter/op_assign.rb#7 -class Unparser::Emitter::BinaryAssign < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/op_assign.rb#17 - def emit_heredoc_reminders; end - - private - - # source://unparser//lib/unparser/emitter/op_assign.rb#24 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def expression; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# source://unparser//lib/unparser/emitter/op_assign.rb#10 -Unparser::Emitter::BinaryAssign::MAP = T.let(T.unsafe(nil), Hash) - -# Block emitter -# -# source://unparser//lib/unparser/emitter/block.rb#7 -class Unparser::Emitter::Block < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def arguments; end - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/block.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/emitter/block.rb#75 - def emit_block_arguments; end - - # source://unparser//lib/unparser/emitter/block.rb#67 - def emit_lambda_arguments; end - - # source://unparser//lib/unparser/emitter/block.rb#61 - def emit_send_target; end - - # source://unparser//lib/unparser/emitter/block.rb#49 - def emit_target; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/block.rb#24 - def need_do?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/block.rb#71 - def numblock?; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def target_writer(&block); end - - # source://unparser//lib/unparser/emitter/block.rb#36 - def write_close; end - - # source://unparser//lib/unparser/emitter/block.rb#28 - def write_open; end -end - -# Block pass node emitter -# -# source://unparser//lib/unparser/emitter/argument.rb#123 -class Unparser::Emitter::BlockPass < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#130 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for toplevel constant reference nodes -# -# source://unparser//lib/unparser/emitter/cbase.rb#6 -class Unparser::Emitter::CBase < ::Unparser::Emitter - private - - # Perform dispatch - # - # @api private - # @return [undefined] - # - # source://unparser//lib/unparser/emitter/cbase.rb#17 - def dispatch; end -end - -# Emitter for case nodes -# -# source://unparser//lib/unparser/emitter/case.rb#6 -class Unparser::Emitter::Case < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def condition; end - - # source://unparser//lib/unparser/emitter/case.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/emitter/case.rb#35 - def emit_condition; end - - # source://unparser//lib/unparser/emitter/case.rb#22 - def emit_else; end - - # source://unparser//lib/unparser/emitter/case.rb#30 - def emit_whens; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def whens(&block); end -end - -# Emitter for case guards -# -# source://unparser//lib/unparser/emitter/case_guard.rb#6 -class Unparser::Emitter::CaseGuard < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def condition; end - - # source://unparser//lib/unparser/emitter/case_guard.rb#19 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/case_guard.rb#10 -Unparser::Emitter::CaseGuard::MAP = T.let(T.unsafe(nil), Hash) - -# Emitter for case matches -# -# source://unparser//lib/unparser/emitter/case_match.rb#6 -class Unparser::Emitter::CaseMatch < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/case_match.rb#20 - def dispatch; end - - # source://unparser//lib/unparser/emitter/case_match.rb#16 - def else_branch; end - - # source://unparser//lib/unparser/emitter/case_match.rb#30 - def emit_else_branch; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def patterns(&block); end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# Emitter for class nodes -# -# source://unparser//lib/unparser/emitter/class.rb#6 -class Unparser::Emitter::Class < ::Unparser::Emitter - include ::Unparser::Emitter::LocalVariableRoot - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def local_variable_scope(&block); end - - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/class.rb#15 - def dispatch; end - - # source://unparser//lib/unparser/emitter/class.rb#23 - def emit_superclass; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def superclass; end -end - -# Emitter for constant access -# -# source://unparser//lib/unparser/emitter/variable.rb#21 -class Unparser::Emitter::Const < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/variable.rb#28 - def dispatch; end - - # source://unparser//lib/unparser/emitter/variable.rb#33 - def emit_scope; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def scope; end -end - -# Emitter for const pattern node -# -# source://unparser//lib/unparser/emitter/const_pattern.rb#6 -class Unparser::Emitter::ConstPattern < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def const; end - - # source://unparser//lib/unparser/emitter/const_pattern.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def pattern; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Dynamic string emitter -# -# source://unparser//lib/unparser/emitter/dstr.rb#6 -class Unparser::Emitter::DStr < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/dstr.rb#10 - def emit_heredoc_reminders; end - - private - - # source://unparser//lib/unparser/emitter/dstr.rb#16 - def dispatch; end -end - -# Dynamic symbol literal emitter -# -# source://unparser//lib/unparser/emitter/dsym.rb#6 -class Unparser::Emitter::DSym < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/dsym.rb#11 - def dispatch; end - - # source://unparser//lib/unparser/emitter/dsym.rb#34 - def emit_begin_child(component); end - - # source://unparser//lib/unparser/emitter/dsym.rb#24 - def emit_str_child(value); end -end - -# Emitter for def node -# -# source://unparser//lib/unparser/emitter/def.rb#6 -class Unparser::Emitter::Def < ::Unparser::Emitter - include ::Unparser::Emitter::LocalVariableRoot - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def local_variable_scope(&block); end - - private - - # source://unparser//lib/unparser/abstract_type.rb#114 - def body(*_arg0); end - - # source://unparser//lib/unparser/emitter/def.rb#17 - def dispatch; end - - # source://unparser//lib/unparser/emitter/def.rb#25 - def emit_arguments; end - - # source://unparser//lib/unparser/abstract_type.rb#114 - def emit_name(*_arg0); end -end - -# Instance def emitter -# -# source://unparser//lib/unparser/emitter/def.rb#34 -class Unparser::Emitter::Def::Instance < ::Unparser::Emitter::Def - private - - # source://unparser//lib/unparser/dsl.rb#18 - def arguments; end - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/def.rb#41 - def emit_name; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for defines on singleton -# -# source://unparser//lib/unparser/emitter/def.rb#48 -class Unparser::Emitter::Def::Singleton < ::Unparser::Emitter::Def - private - - # source://unparser//lib/unparser/dsl.rb#18 - def arguments; end - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/def.rb#56 - def emit_name; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def subject; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/def.rb#63 - def subject_without_parens?; end -end - -# Emitter for defined? nodes -# -# source://unparser//lib/unparser/emitter/defined.rb#6 -class Unparser::Emitter::Defined < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/defined.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def subject; end -end - -# Emitter for in pattern nodes -# -# source://unparser//lib/unparser/emitter/find_pattern.rb#6 -class Unparser::Emitter::FindPattern < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/find_pattern.rb#11 - def dispatch; end -end - -# Emitter for flip flops -# -# source://unparser//lib/unparser/emitter/flipflop.rb#6 -class Unparser::Emitter::FlipFlop < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/flipflop.rb#17 - def symbol_name; end - - private - - # source://unparser//lib/unparser/emitter/flipflop.rb#27 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def left; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def right; end -end - -# source://unparser//lib/unparser/emitter/flipflop.rb#7 -Unparser::Emitter::FlipFlop::MAP = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/emitter/flipflop.rb#12 -Unparser::Emitter::FlipFlop::SYMBOLS = T.let(T.unsafe(nil), Hash) - -# Emiter for float literals -# -# source://unparser//lib/unparser/emitter/float.rb#6 -class Unparser::Emitter::Float < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/float.rb#16 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def value; end -end - -# source://unparser//lib/unparser/emitter/float.rb#11 -Unparser::Emitter::Float::INFINITY = T.let(T.unsafe(nil), Float) - -# source://unparser//lib/unparser/emitter/float.rb#12 -Unparser::Emitter::Float::NEG_INFINITY = T.let(T.unsafe(nil), Float) - -# Emitter control flow modifiers -# -# source://unparser//lib/unparser/emitter/flow_modifier.rb#6 -class Unparser::Emitter::FlowModifier < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/flow_modifier.rb#17 - def emit_heredoc_reminders; end - - private - - # source://unparser//lib/unparser/emitter/flow_modifier.rb#25 - def dispatch; end - - # source://unparser//lib/unparser/emitter/flow_modifier.rb#36 - def emit_arguments; end -end - -# source://unparser//lib/unparser/emitter/flow_modifier.rb#7 -Unparser::Emitter::FlowModifier::MAP = T.let(T.unsafe(nil), Hash) - -# Emitter for for nodes -# -# source://unparser//lib/unparser/emitter/for.rb#6 -class Unparser::Emitter::For < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def assignment; end - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/dsl.rb#18 - def condition; end - - # source://unparser//lib/unparser/emitter/for.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/emitter/for.rb#20 - def emit_condition; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for forwarding arguments -# -# source://unparser//lib/unparser/emitter/argument.rb#6 -class Unparser::Emitter::ForwardArg < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#20 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/argument.rb#7 -Unparser::Emitter::ForwardArg::MAP = T.let(T.unsafe(nil), Hash) - -# Emitter for Hash literals -# -# source://unparser//lib/unparser/emitter/hash.rb#6 -class Unparser::Emitter::Hash < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/hash.rb#9 - def emit_heredoc_reminders; end - - private - - # source://unparser//lib/unparser/emitter/hash.rb#15 - def dispatch; end - - # source://unparser//lib/unparser/emitter/hash.rb#31 - def emit_hash_body; end - - # source://unparser//lib/unparser/emitter/hash.rb#27 - def emit_heredoc_reminder_member(node); end -end - -# Emitter for hash patterns -# -# source://unparser//lib/unparser/emitter/hash_pattern.rb#6 -class Unparser::Emitter::HashPattern < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/hash_pattern.rb#10 - def emit_const_pattern; end - - private - - # source://unparser//lib/unparser/emitter/hash_pattern.rb#18 - def dispatch; end - - # source://unparser//lib/unparser/emitter/hash_pattern.rb#24 - def emit_hash_body; end - - # source://unparser//lib/unparser/emitter/hash_pattern.rb#41 - def emit_match_var(node); end - - # source://unparser//lib/unparser/emitter/hash_pattern.rb#28 - def emit_member(node); end - - # source://unparser//lib/unparser/emitter/hash_pattern.rb#46 - def emit_pair(node); end - - # source://unparser//lib/unparser/emitter/hash_pattern.rb#62 - def write_symbol_body(symbol); end -end - -# Base class for pre and postexe emitters -# -# source://unparser//lib/unparser/emitter/hookexe.rb#6 -class Unparser::Emitter::Hookexe < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/hookexe.rb#19 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/hookexe.rb#8 -Unparser::Emitter::Hookexe::MAP = T.let(T.unsafe(nil), Hash) - -# Emitter if nodes -# -# source://unparser//lib/unparser/emitter/if.rb#6 -class Unparser::Emitter::If < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/if.rb#11 - def emit_ternary; end - - private - - # source://unparser//lib/unparser/dsl.rb#18 - def condition; end - - # source://unparser//lib/unparser/emitter/if.rb#21 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def else_branch; end - - # source://unparser//lib/unparser/emitter/if.rb#59 - def emit_condition; end - - # source://unparser//lib/unparser/emitter/if.rb#71 - def emit_else_branch; end - - # source://unparser//lib/unparser/emitter/if.rb#63 - def emit_if_branch; end - - # source://unparser//lib/unparser/emitter/if.rb#43 - def emit_normal; end - - # source://unparser//lib/unparser/emitter/if.rb#37 - def emit_postcondition; end - - # source://unparser//lib/unparser/dsl.rb#18 - def if_branch; end - - # source://unparser//lib/unparser/emitter/if.rb#55 - def keyword; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/if.rb#29 - def postcondition?; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/if.rb#51 - def unless?; end -end - -# Emitter for in pattern nodes -# -# source://unparser//lib/unparser/emitter/in_match.rb#6 -class Unparser::Emitter::InMatch < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/in_match.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def pattern; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# Emitter for in pattern nodes -# -# source://unparser//lib/unparser/emitter/in_pattern.rb#6 -class Unparser::Emitter::InPattern < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def branch; end - - # source://unparser//lib/unparser/emitter/in_pattern.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def else_branch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end - - # source://unparser//lib/unparser/dsl.rb#18 - def unless_guard; end -end - -# Emitter for send to index references -# -# source://unparser//lib/unparser/emitter/index.rb#6 -class Unparser::Emitter::Index < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/index.rb#10 - def dispatch; end - - # source://unparser//lib/unparser/emitter/index.rb#15 - def emit_receiver; end -end - -# Emitter for assign to index nodes -# -# source://unparser//lib/unparser/emitter/index.rb#34 -class Unparser::Emitter::Index::Assign < ::Unparser::Emitter::Index - # source://unparser//lib/unparser/emitter/index.rb#47 - def dispatch; end - - # source://unparser//lib/unparser/emitter/index.rb#43 - def emit_heredoc_reminders; end - - # source://unparser//lib/unparser/emitter/index.rb#54 - def emit_mlhs; end - - private - - # source://unparser//lib/unparser/emitter/index.rb#61 - def emit_operation(indices); end -end - -# source://unparser//lib/unparser/emitter/index.rb#39 -Unparser::Emitter::Index::Assign::NO_VALUE_PARENT = T.let(T.unsafe(nil), Set) - -# source://unparser//lib/unparser/emitter/index.rb#38 -Unparser::Emitter::Index::Assign::VALUE_RANGE = T.let(T.unsafe(nil), Range) - -# source://unparser//lib/unparser/emitter/index.rb#19 -class Unparser::Emitter::Index::Reference < ::Unparser::Emitter::Index - private - - # source://unparser//lib/unparser/emitter/index.rb#26 - def emit_operation; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def indices(&block); end -end - -# Emitter for explicit begins -# -# source://unparser//lib/unparser/emitter/kwbegin.rb#6 -class Unparser::Emitter::KWBegin < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/kwbegin.rb#11 - def dispatch; end - - # source://unparser//lib/unparser/emitter/kwbegin.rb#25 - def emit_multiple_body; end -end - -# Optional keyword argument emitter -# -# source://unparser//lib/unparser/emitter/argument.rb#41 -class Unparser::Emitter::KeywordOptional < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#48 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def value; end -end - -# Emitter for splats -# -# source://unparser//lib/unparser/emitter/splat.rb#6 -class Unparser::Emitter::KwSplat < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/splat.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def subject; end -end - -# Keyword argument emitter -# -# source://unparser//lib/unparser/emitter/argument.rb#56 -class Unparser::Emitter::Kwarg < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#63 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/kwargs.rb#5 -class Unparser::Emitter::Kwargs < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/kwargs.rb#8 - def dispatch; end -end - -# Emitter for lambda nodes -# -# source://unparser//lib/unparser/emitter/lambda.rb#6 -class Unparser::Emitter::Lambda < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/lambda.rb#11 - def dispatch; end -end - -# source://unparser//lib/unparser/emitter.rb#20 -module Unparser::Emitter::LocalVariableRoot - # Return local variable root - # - # @api private - # @return [Parser::AST::Node] - # - # source://unparser//lib/unparser/emitter.rb#27 - def local_variable_scope; end - - class << self - # @private - # - # source://unparser//lib/unparser/emitter.rb#31 - def included(descendant); end - end -end - -# Emitter for multiple assignment nodes -# -# source://unparser//lib/unparser/emitter/masgn.rb#6 -class Unparser::Emitter::MASGN < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/masgn.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def source; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# Emitter for multiple assignment left hand side -# -# source://unparser//lib/unparser/emitter/mlhs.rb#6 -class Unparser::Emitter::MLHS < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/mlhs.rb#15 - def dispatch; end - - # source://unparser//lib/unparser/emitter/mlhs.rb#31 - def emit_many; end - - # source://unparser//lib/unparser/emitter/mlhs.rb#23 - def emit_one_child_mlhs; end -end - -# source://unparser//lib/unparser/emitter/mlhs.rb#9 -Unparser::Emitter::MLHS::NO_COMMA = T.let(T.unsafe(nil), Array) - -# Base class for special match node emitters -# -# source://unparser//lib/unparser/emitter/match.rb#8 -class Unparser::Emitter::Match < ::Unparser::Emitter; end - -# Emitter for match current line -# -# source://unparser//lib/unparser/emitter/match.rb#25 -class Unparser::Emitter::Match::CurrentLine < ::Unparser::Emitter::Match - private - - # source://unparser//lib/unparser/emitter/match.rb#32 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def regexp; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for match with local variable assignment -# -# source://unparser//lib/unparser/emitter/match.rb#9 -class Unparser::Emitter::Match::Lvasgn < ::Unparser::Emitter::Match - private - - # source://unparser//lib/unparser/emitter/match.rb#16 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def lvasgn; end - - # source://unparser//lib/unparser/dsl.rb#18 - def regexp; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for in pattern nodes -# -# source://unparser//lib/unparser/emitter/match_alt.rb#6 -class Unparser::Emitter::MatchAlt < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/match_alt.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def left; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def right; end -end - -# Emitter for in pattern nodes -# -# source://unparser//lib/unparser/emitter/match_as.rb#6 -class Unparser::Emitter::MatchAs < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/match_as.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def left; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def right; end -end - -# Emitter for in pattern nodes -# -# source://unparser//lib/unparser/emitter/match_pattern.rb#6 -class Unparser::Emitter::MatchPattern < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/match_pattern.rb#23 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def pattern; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# Modern ast format emits `match_pattern` -# node on single line pre 3.0, but 3.0+ uses `match_pattern_p` -# -# source://unparser//lib/unparser/emitter/match_pattern.rb#14 -Unparser::Emitter::MatchPattern::SYMBOL = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/emitter/match_pattern_p.rb#5 -class Unparser::Emitter::MatchPatternP < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/match_pattern_p.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def pattern; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# Emiter for match rest nodes -# -# source://unparser//lib/unparser/emitter/match_rest.rb#6 -class Unparser::Emitter::MatchRest < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/match_rest.rb#11 - def dispatch; end - - # source://unparser//lib/unparser/emitter/match_rest.rb#16 - def emit_array_pattern; end - - # source://unparser//lib/unparser/emitter/match_rest.rb#21 - def emit_hash_pattern; end - - private - - # source://unparser//lib/unparser/emitter/match_rest.rb#28 - def emit_match_var; end - - # source://unparser//lib/unparser/dsl.rb#18 - def match_var; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for in pattern nodes -# -# source://unparser//lib/unparser/emitter/match_var.rb#6 -class Unparser::Emitter::MatchVar < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/match_var.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for module nodes -# -# source://unparser//lib/unparser/emitter/module.rb#6 -class Unparser::Emitter::Module < ::Unparser::Emitter - include ::Unparser::Emitter::LocalVariableRoot - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def local_variable_scope(&block); end - - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/module.rb#15 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter.rb#18 -Unparser::Emitter::NO_INDENT = T.let(T.unsafe(nil), Array) - -# Emitter for nth_ref nodes (regexp captures) -# -# source://unparser//lib/unparser/emitter/variable.rb#42 -class Unparser::Emitter::NthRef < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/variable.rb#50 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/variable.rb#43 -Unparser::Emitter::NthRef::PREFIX = T.let(T.unsafe(nil), String) - -# Emitter for op assign -# -# source://unparser//lib/unparser/emitter/op_assign.rb#33 -class Unparser::Emitter::OpAssign < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/op_assign.rb#40 - def dispatch; end - - # source://unparser//lib/unparser/emitter/op_assign.rb#46 - def emit_operator; end - - # source://unparser//lib/unparser/dsl.rb#18 - def operator; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end - - # source://unparser//lib/unparser/dsl.rb#18 - def value; end -end - -# Optional argument emitter -# -# source://unparser//lib/unparser/emitter/argument.rb#27 -class Unparser::Emitter::Optarg < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#34 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def value; end -end - -# Emitter for key value pairs in hash literals or kwargs -# -# source://unparser//lib/unparser/emitter/pair.rb#6 -class Unparser::Emitter::Pair < ::Unparser::Emitter - private - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/pair.rb#28 - def colon?(key); end - - # source://unparser//lib/unparser/emitter/pair.rb#17 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def key; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def value; end -end - -# source://unparser//lib/unparser/emitter/pair.rb#7 -Unparser::Emitter::Pair::BAREWORD = T.let(T.unsafe(nil), Regexp) - -# Emitter for pin nodes -# -# source://unparser//lib/unparser/emitter/pin.rb#6 -class Unparser::Emitter::Pin < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/pin.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def target; end -end - -# Emitter for postconditions -# -# source://unparser//lib/unparser/emitter/repetition.rb#7 -class Unparser::Emitter::Post < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/dsl.rb#18 - def condition; end - - # source://unparser//lib/unparser/emitter/repetition.rb#19 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/repetition.rb#10 -Unparser::Emitter::Post::MAP = T.let(T.unsafe(nil), Hash) - -# Base class for primitive emitters -# -# source://unparser//lib/unparser/emitter/primitive.rb#6 -class Unparser::Emitter::Primitive < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def value; end -end - -# Emitter for complex literals -# -# source://unparser//lib/unparser/emitter/primitive.rb#24 -class Unparser::Emitter::Primitive::Complex < ::Unparser::Emitter::Primitive - private - - # source://unparser//lib/unparser/emitter/primitive.rb#39 - def dispatch; end - - # source://unparser//lib/unparser/emitter/primitive.rb#44 - def emit_imaginary; end - - # source://unparser//lib/unparser/emitter/primitive.rb#48 - def imaginary_node; end -end - -# source://unparser//lib/unparser/emitter/primitive.rb#30 -Unparser::Emitter::Primitive::Complex::MAP = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/emitter/primitive.rb#28 -Unparser::Emitter::Primitive::Complex::RATIONAL_FORMAT = T.let(T.unsafe(nil), String) - -# Emitter for primitives based on Object#inspect -# -# source://unparser//lib/unparser/emitter/primitive.rb#11 -class Unparser::Emitter::Primitive::Inspect < ::Unparser::Emitter::Primitive - private - - # source://unparser//lib/unparser/emitter/primitive.rb#17 - def dispatch; end -end - -# Emiter for numeric literals -# -# source://unparser//lib/unparser/emitter/primitive.rb#80 -class Unparser::Emitter::Primitive::Numeric < ::Unparser::Emitter::Primitive - private - - # source://unparser//lib/unparser/emitter/primitive.rb#86 - def dispatch; end -end - -# Emitter for rational literals -# -# source://unparser//lib/unparser/emitter/primitive.rb#56 -class Unparser::Emitter::Primitive::Rational < ::Unparser::Emitter::Primitive - private - - # source://unparser//lib/unparser/emitter/primitive.rb#65 - def dispatch; end - - # source://unparser//lib/unparser/emitter/primitive.rb#73 - def write_rational(value); end -end - -# source://unparser//lib/unparser/emitter/primitive.rb#60 -Unparser::Emitter::Primitive::Rational::RATIONAL_FORMAT = T.let(T.unsafe(nil), String) - -# Progarg emitter -# -# source://unparser//lib/unparser/emitter/argument.rb#98 -class Unparser::Emitter::Procarg < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#105 - def dispatch; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/argument.rb#115 - def needs_parens?; end -end - -# source://unparser//lib/unparser/emitter/argument.rb#101 -Unparser::Emitter::Procarg::PARENS = T.let(T.unsafe(nil), Array) - -# Registry for node emitters -# -# source://unparser//lib/unparser/emitter.rb#16 -Unparser::Emitter::REGISTRY = T.let(T.unsafe(nil), Hash) - -# Range emitters -# -# source://unparser//lib/unparser/emitter/range.rb#6 -class Unparser::Emitter::Range < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/range.rb#17 - def symbol_name; end - - private - - # source://unparser//lib/unparser/dsl.rb#18 - def begin_node; end - - # source://unparser//lib/unparser/emitter/range.rb#27 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def end_node; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/range.rb#12 -Unparser::Emitter::Range::SYMBOLS = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/emitter/range.rb#7 -Unparser::Emitter::Range::TOKENS = T.let(T.unsafe(nil), Hash) - -# Emitter for regexp literals -# -# source://unparser//lib/unparser/emitter/regexp.rb#6 -class Unparser::Emitter::Regexp < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def body(&block); end - - # source://unparser//lib/unparser/emitter/regexp.rb#13 - def dispatch; end - - # source://unparser//lib/unparser/emitter/regexp.rb#24 - def emit_body(node); end - - # source://unparser//lib/unparser/emitter/regexp.rb#20 - def emit_options; end -end - -# Emitter for while and until nodes -# -# source://unparser//lib/unparser/emitter/repetition.rb#27 -class Unparser::Emitter::Repetition < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/dsl.rb#18 - def condition; end - - # source://unparser//lib/unparser/emitter/repetition.rb#39 - def dispatch; end - - # source://unparser//lib/unparser/emitter/repetition.rb#51 - def emit_keyword; end - - # source://unparser//lib/unparser/emitter/repetition.rb#55 - def emit_normal; end - - # source://unparser//lib/unparser/emitter/repetition.rb#66 - def emit_postcontrol; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/repetition.rb#47 - def postcontrol?; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/emitter/repetition.rb#28 -Unparser::Emitter::Repetition::MAP = T.let(T.unsafe(nil), Hash) - -# Emitter for rescue nodes -# -# source://unparser//lib/unparser/emitter/rescue.rb#6 -class Unparser::Emitter::Rescue < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/rescue.rb#11 - def dispatch; end -end - -# Rest argument emitter -# -# source://unparser//lib/unparser/emitter/argument.rb#70 -class Unparser::Emitter::Restarg < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/argument.rb#77 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Root emitter a special case -# -# source://unparser//lib/unparser/emitter/root.rb#6 -class Unparser::Emitter::Root < ::Unparser::Emitter - include ::Unparser::Emitter::LocalVariableRoot - - # source://unparser//lib/unparser/emitter/root.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def local_variable_scope(&block); end -end - -# source://unparser//lib/unparser/emitter/root.rb#10 -Unparser::Emitter::Root::END_NL = T.let(T.unsafe(nil), Array) - -# Emitter for sclass nodes -# -# source://unparser//lib/unparser/emitter/class.rb#33 -class Unparser::Emitter::SClass < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/emitter/class.rb#40 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def object; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for send -# -# source://unparser//lib/unparser/emitter/send.rb#6 -class Unparser::Emitter::Send < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/send.rb#13 - def emit_heredoc_reminders; end - - # source://unparser//lib/unparser/emitter/send.rb#9 - def emit_mlhs; end - - private - - # source://unparser//lib/unparser/emitter/send.rb#19 - def dispatch; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def writer(&block); end -end - -# Emitter for simple nodes that generate a single token -# -# source://unparser//lib/unparser/emitter/simple.rb#6 -class Unparser::Emitter::Simple < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/simple.rb#28 - def dispatch; end -end - -# source://unparser//lib/unparser/emitter/simple.rb#7 -Unparser::Emitter::Simple::MAP = T.let(T.unsafe(nil), Hash) - -# Emitter for splats -# -# source://unparser//lib/unparser/emitter/splat.rb#20 -class Unparser::Emitter::Splat < ::Unparser::Emitter - # source://unparser//lib/unparser/emitter/splat.rb#25 - def emit_mlhs; end - - private - - # source://unparser//lib/unparser/emitter/splat.rb#32 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def subject; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def subject_emitter(&block); end -end - -# Emitter for super nodes -# -# source://unparser//lib/unparser/emitter/super.rb#7 -class Unparser::Emitter::Super < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/super.rb#12 - def dispatch; end -end - -# Emitter for undef nodes -# -# source://unparser//lib/unparser/emitter/undef.rb#6 -class Unparser::Emitter::Undef < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/undef.rb#11 - def dispatch; end -end - -# Emitter for various variable accesses -# -# source://unparser//lib/unparser/emitter/variable.rb#7 -class Unparser::Emitter::Variable < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/variable.rb#14 - def dispatch; end - - # source://unparser//lib/unparser/dsl.rb#18 - def name; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# Emitter for when nodes -# -# source://unparser//lib/unparser/emitter/case.rb#44 -class Unparser::Emitter::When < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def captures(&block); end - - # source://unparser//lib/unparser/emitter/case.rb#51 - def dispatch; end - - # source://unparser//lib/unparser/emitter/case.rb#57 - def emit_captures; end -end - -# Dynamic execute string literal emitter -# -# source://unparser//lib/unparser/emitter/xstr.rb#6 -class Unparser::Emitter::XStr < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/xstr.rb#12 - def dispatch; end - - # source://unparser//lib/unparser/emitter/xstr.rb#65 - def emit_begin(component); end - - # source://unparser//lib/unparser/emitter/xstr.rb#24 - def emit_heredoc; end - - # source://unparser//lib/unparser/emitter/xstr.rb#51 - def emit_string(value); end - - # source://unparser//lib/unparser/emitter/xstr.rb#39 - def emit_xstr; end - - # source://unparser//lib/unparser/emitter/xstr.rb#55 - def escape_xstr(input); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/emitter/xstr.rb#20 - def heredoc?; end -end - -# Emitter for yield node -# -# source://unparser//lib/unparser/emitter/yield.rb#7 -class Unparser::Emitter::Yield < ::Unparser::Emitter - private - - # source://unparser//lib/unparser/emitter/yield.rb#12 - def dispatch; end -end - -# Define equality, equivalence and inspection methods -# -# Original code before vendoring and reduction from: https://github.com/dkubb/equalizer. -# -# source://unparser//lib/unparser/equalizer.rb#19 -class Unparser::Equalizer < ::Module - # Initialize an Equalizer with the given keys - # - # Will use the keys with which it is initialized to define #cmp?, - # #hash, and #inspect - # - # - # @api private - # @param keys [Array] - # @return [undefined] - # - # source://unparser//lib/unparser/equalizer.rb#20 - def initialize(*keys); end - - private - - # source://unparser//lib/unparser/equalizer.rb#39 - def define_cmp_method; end - - # source://unparser//lib/unparser/equalizer.rb#49 - def define_hash_method; end - - # source://unparser//lib/unparser/equalizer.rb#56 - def define_inspect_method; end - - # source://unparser//lib/unparser/equalizer.rb#33 - def define_methods; end - - # source://unparser//lib/unparser/equalizer.rb#29 - def included(descendant); end -end - -# The comparison methods -# -# source://unparser//lib/unparser/equalizer.rb#66 -module Unparser::Equalizer::Methods - # Compare the object with other object for equivalency - # - # @api public - # @example - # object == other # => true or false - # @param other [Object] the other object to compare with - # @return [Boolean] - # - # source://unparser//lib/unparser/equalizer.rb#93 - def ==(other); end - - # Compare the object with other object for equality - # - # @api public - # @example - # object.eql?(other) # => true or false - # @param other [Object] the other object to compare with - # @return [Boolean] - # - # source://unparser//lib/unparser/equalizer.rb#78 - def eql?(other); end -end - -# source://unparser//lib/unparser/generation.rb#5 -module Unparser::Generation - # source://unparser//lib/unparser/generation.rb#10 - def emit_heredoc_reminders; end - - # source://unparser//lib/unparser/generation.rb#12 - def symbol_name; end - - # source://unparser//lib/unparser/generation.rb#14 - def write_to_buffer; end - - private - - # source://unparser//lib/unparser/generation.rb#247 - def children; end - - # source://unparser//lib/unparser/generation.rb#239 - def conditional_parentheses(flag, &block); end - - # source://unparser//lib/unparser/generation.rb#21 - def delimited(nodes, delimiter = T.unsafe(nil), &block); end - - # source://unparser//lib/unparser/generation.rb#123 - def emit_body(node, indent: T.unsafe(nil)); end - - # source://unparser//lib/unparser/generation.rb#196 - def emit_body_ensure_rescue(node); end - - # source://unparser//lib/unparser/generation.rb#145 - def emit_body_inner(node); end - - # source://unparser//lib/unparser/generation.rb#158 - def emit_body_member(node); end - - # source://unparser//lib/unparser/generation.rb#180 - def emit_body_rescue(node); end - - # source://unparser//lib/unparser/generation.rb#77 - def emit_comments(comments); end - - # source://unparser//lib/unparser/generation.rb#69 - def emit_comments_before(source_part = T.unsafe(nil)); end - - # source://unparser//lib/unparser/generation.rb#166 - def emit_ensure(node); end - - # source://unparser//lib/unparser/generation.rb#60 - def emit_eof_comments; end - - # source://unparser//lib/unparser/generation.rb#54 - def emit_eol_comments; end - - # source://unparser//lib/unparser/generation.rb#27 - def emit_join(nodes, emit_node, emit_delimiter); end - - # source://unparser//lib/unparser/generation.rb#115 - def emit_optional_body(node, indent: T.unsafe(nil)); end - - # source://unparser//lib/unparser/generation.rb#188 - def emit_optional_body_ensure_rescue(node); end - - # source://unparser//lib/unparser/generation.rb#206 - def emit_rescue_postcontrol(node); end - - # source://unparser//lib/unparser/generation.rb#212 - def emit_rescue_regular(node); end - - # source://unparser//lib/unparser/generation.rb#220 - def emitter(node); end - - # source://unparser//lib/unparser/generation.rb#235 - def first_child; end - - # source://unparser//lib/unparser/generation.rb#106 - def indented; end - - # source://unparser//lib/unparser/generation.rb#93 - def k_end; end - - # source://unparser//lib/unparser/generation.rb#39 - def nl; end - - # source://unparser//lib/unparser/generation.rb#100 - def parentheses(open = T.unsafe(nil), close = T.unsafe(nil)); end - - # source://unparser//lib/unparser/generation.rb#224 - def visit(node); end - - # source://unparser//lib/unparser/generation.rb#228 - def visit_deep(node); end - - # source://unparser//lib/unparser/generation.rb#44 - def with_comments; end - - # source://unparser//lib/unparser/generation.rb#89 - def write(*strings); end - - # source://unparser//lib/unparser/generation.rb#216 - def writer_with(klass, node); end - - # source://unparser//lib/unparser/generation.rb#50 - def ws; end -end - -# source://unparser//lib/unparser/generation.rb#6 -Unparser::Generation::EXTRA_NL = T.let(T.unsafe(nil), Array) - -# Error raised when unparser encounters an invalid AST -# -# source://unparser//lib/unparser.rb#39 -class Unparser::InvalidNodeError < ::RuntimeError - # @return [InvalidNodeError] a new instance of InvalidNodeError - # - # source://unparser//lib/unparser.rb#42 - def initialize(message, node); end - - # Returns the value of attribute node. - # - # source://unparser//lib/unparser.rb#40 - def node; end -end - -# source://unparser//lib/unparser/node_details.rb#4 -module Unparser::NodeDetails - include ::Unparser::NodeHelpers - include ::Unparser::Constants - - private - - # source://unparser//lib/unparser/node_details.rb#17 - def children; end - - class << self - # @private - # - # source://unparser//lib/unparser/node_details.rb#7 - def included(descendant); end - end -end - -# source://unparser//lib/unparser/node_details/send.rb#5 -class Unparser::NodeDetails::Send - include ::Unparser::NodeHelpers - include ::Unparser::Constants - include ::Unparser::NodeDetails - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - extend ::Unparser::DSL - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def arguments(&block); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/node_details/send.rb#36 - def arguments?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def assignment?(&block); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/node_details/send.rb#32 - def assignment_operator?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/node_details/send.rb#21 - def binary_syntax_allowed?; end - - # source://unparser//lib/unparser/node_details/send.rb#40 - def non_assignment_selector; end - - # source://unparser//lib/unparser/dsl.rb#18 - def receiver; end - - # source://unparser//lib/unparser/dsl.rb#18 - def selector; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/node_details/send.rb#17 - def selector_binary_operator?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/node_details/send.rb#28 - def selector_unary_operator?; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def string_selector(&block); end - - private - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end -end - -# source://unparser//lib/unparser/node_details/send.rb#8 -Unparser::NodeDetails::Send::ASSIGN_SUFFIX = T.let(T.unsafe(nil), String) - -# source://unparser//lib/unparser/node_details/send.rb#9 -Unparser::NodeDetails::Send::NON_ASSIGN_RANGE = T.let(T.unsafe(nil), Range) - -# source://unparser//lib/unparser/node_helpers.rb#4 -module Unparser::NodeHelpers - # Helper for building nodes - # - # @api private - # @param type [Symbol] - # @param children [Array] - # @return [Parser::AST::Node] - # - # source://unparser//lib/unparser/node_helpers.rb#26 - def n(type, children = T.unsafe(nil)); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/node_helpers.rb#30 - def n?(type, node); end - - # Helper for building nodes - # - # @api private - # @param type [Symbol] - # @param children [Parser::AST::Node] - # @return [Parser::AST::Node] - # - # source://unparser//lib/unparser/node_helpers.rb#14 - def s(type, *children); end - - # source://unparser//lib/unparser/node_helpers.rb#71 - def unwrap_single_begin(node); end - - private - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_arg?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_args?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_array?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_array_pattern?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_begin?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_block?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_cbase?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_const?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_dstr?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_empty_else?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_ensure?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_hash?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_hash_pattern?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_if?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_in_pattern?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_int?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_kwarg?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_kwargs?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_kwsplat?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_lambda?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_match_rest?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_pair?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_rescue?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_send?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_shadowarg?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_splat?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_str?(node); end - - # source://unparser//lib/unparser/node_helpers.rb#65 - def n_sym?(node); end -end - -# source://unparser//lib/unparser/either.rb#4 -module Unparser::RequireBlock - private - - # Raise error unless block is provided - # - # @raise [MissingBlockError] if no block is given - # @return [self] - # - # source://unparser//lib/unparser/either.rb#14 - def require_block; end -end - -# source://unparser//lib/unparser/emitter.rb#4 -class Unparser::UnknownNodeError < ::ArgumentError; end - -# Validation of unparser results -# -# source://unparser//lib/unparser/validation.rb#5 -class Unparser::Validation - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - - # source://unparser//lib/unparser/anima.rb#146 - def generated_node; end - - # source://unparser//lib/unparser/anima.rb#146 - def generated_source; end - - # source://unparser//lib/unparser/anima.rb#146 - def identification; end - - # source://unparser//lib/unparser/anima.rb#146 - def original_node; end - - # source://unparser//lib/unparser/anima.rb#146 - def original_source; end - - # Return error report - # - # @api private - # @return [String] - # - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def report(&block); end - - # Test if source could be unparsed successfully - # - # @api private - # @return [Boolean] - # - # source://unparser//lib/unparser/validation.rb#20 - def success?; end - - private - - # source://unparser//lib/unparser/validation.rb#106 - def make_report(label, attribute_name); end - - # source://unparser//lib/unparser/validation.rb#118 - def node_diff_report; end - - # source://unparser//lib/unparser/validation.rb#110 - def report_exception(exception); end - - class << self - # source://unparser//lib/unparser/anima.rb#140 - def anima; end - - # Create validator from node - # - # @param original_node [Parser::AST::Node] - # @return [Validator] - # - # source://unparser//lib/unparser/validation.rb#79 - def from_node(original_node); end - - # Create validator from file - # - # @param path [Pathname] - # @return [Validator] - # - # source://unparser//lib/unparser/validation.rb#100 - def from_path(path); end - - # Create validator from string - # - # @param original_source [String] - # @return [Validator] - # - # source://unparser//lib/unparser/validation.rb#53 - def from_string(original_source); end - - private - - # source://unparser//lib/unparser/validation.rb#133 - def const_unit(_value); end - end -end - -# source://unparser//lib/unparser/validation.rb#136 -class Unparser::Validation::Literal < ::Unparser::Validation - # source://unparser//lib/unparser/validation.rb#141 - def report; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/validation.rb#137 - def success?; end - - private - - # source://unparser//lib/unparser/validation.rb#156 - def source_diff_report; end -end - -# source://unparser//lib/unparser/writer.rb#4 -module Unparser::Writer - include ::Unparser::NodeHelpers - include ::Unparser::Generation - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - - mixes_in_class_methods ::Unparser::DSL - - class << self - # @private - # - # source://unparser//lib/unparser/writer.rb#7 - def included(descendant); end - end -end - -# source://unparser//lib/unparser/writer/binary.rb#5 -class Unparser::Writer::Binary - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - include ::Unparser::NodeHelpers - include ::Unparser::Generation - include ::Unparser::Writer - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - extend ::Unparser::DSL - - # source://unparser//lib/unparser/anima.rb#146 - def buffer; end - - # source://unparser//lib/unparser/anima.rb#146 - def comments; end - - # source://unparser//lib/unparser/writer/binary.rb#54 - def dispatch; end - - # source://unparser//lib/unparser/writer/binary.rb#46 - def emit_operator; end - - # source://unparser//lib/unparser/anima.rb#146 - def local_variable_scope; end - - # source://unparser//lib/unparser/anima.rb#146 - def node; end - - # source://unparser//lib/unparser/writer/binary.rb#50 - def symbol_name; end - - private - - # source://unparser//lib/unparser/writer/binary.rb#62 - def effective_symbol; end - - # source://unparser//lib/unparser/writer/binary.rb#74 - def emit_with(map); end - - # source://unparser//lib/unparser/writer/binary.rb#80 - def keyword_symbol; end - - # source://unparser//lib/unparser/dsl.rb#18 - def left; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def left_emitter(&block); end - - # source://unparser//lib/unparser/writer/binary.rb#84 - def operator_symbol; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def right; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def right_emitter(&block); end - - class << self - # source://unparser//lib/unparser/anima.rb#140 - def anima; end - end -end - -# source://unparser//lib/unparser/writer/binary.rb#22 -Unparser::Writer::Binary::KEYWORD_SYMBOLS = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/writer/binary.rb#16 -Unparser::Writer::Binary::KEYWORD_TOKENS = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/writer/binary.rb#34 -Unparser::Writer::Binary::MAP = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/writer/binary.rb#42 -Unparser::Writer::Binary::NEED_KEYWORD = T.let(T.unsafe(nil), Array) - -# source://unparser//lib/unparser/writer/binary.rb#28 -Unparser::Writer::Binary::OPERATOR_SYMBOLS = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/writer/binary.rb#10 -Unparser::Writer::Binary::OPERATOR_TOKENS = T.let(T.unsafe(nil), Hash) - -# source://unparser//lib/unparser/writer/dynamic_string.rb#5 -class Unparser::Writer::DynamicString - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - include ::Unparser::NodeHelpers - include ::Unparser::Generation - include ::Unparser::Writer - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - extend ::Unparser::DSL - - # source://unparser//lib/unparser/anima.rb#146 - def buffer; end - - # source://unparser//lib/unparser/anima.rb#146 - def comments; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#32 - def dispatch; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#25 - def emit_heredoc_reminder; end - - # source://unparser//lib/unparser/anima.rb#146 - def local_variable_scope; end - - # source://unparser//lib/unparser/anima.rb#146 - def node; end - - private - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#159 - def breakpoint?(child, current); end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#63 - def classify(node); end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#71 - def classify_str(node); end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#193 - def emit_body(children); end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#149 - def emit_dstr; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#132 - def emit_dynamic(child); end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#145 - def emit_dynamic_component(node); end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#54 - def emit_heredoc_body; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#59 - def emit_heredoc_footer; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#50 - def emit_heredoc_header; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#116 - def emit_normal_heredoc_body; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#185 - def emit_segment(children, index); end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#128 - def escape_dynamic(string); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#46 - def heredoc?; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#42 - def heredoc_header; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#95 - def heredoc_pattern?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#105 - def heredoc_pattern_2?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#99 - def heredoc_pattern_3?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#111 - def nl_last_child?; end - - # source://unparser//lib/unparser/writer/dynamic_string.rb#169 - def segments; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#87 - def str_empty?(node); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#83 - def str_nl?(node); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/dynamic_string.rb#91 - def str_ws?(node); end - - class << self - # source://unparser//lib/unparser/anima.rb#140 - def anima; end - end -end - -# source://unparser//lib/unparser/writer/dynamic_string.rb#21 -Unparser::Writer::DynamicString::FLAT_INTERPOLATION = T.let(T.unsafe(nil), Set) - -# source://unparser//lib/unparser/writer/dynamic_string.rb#8 -Unparser::Writer::DynamicString::PATTERNS_2 = T.let(T.unsafe(nil), Array) - -# source://unparser//lib/unparser/writer/dynamic_string.rb#14 -Unparser::Writer::DynamicString::PATTERNS_3 = T.let(T.unsafe(nil), Array) - -# Writer for rescue bodies -# -# source://unparser//lib/unparser/writer/resbody.rb#6 -class Unparser::Writer::Resbody - include ::Unparser::NodeHelpers - include ::Unparser::Generation - include ::Unparser::Writer - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - extend ::Unparser::DSL - - # source://unparser//lib/unparser/anima.rb#146 - def buffer; end - - # source://unparser//lib/unparser/anima.rb#146 - def comments; end - - # source://unparser//lib/unparser/writer/resbody.rb#11 - def emit_postcontrol; end - - # source://unparser//lib/unparser/writer/resbody.rb#16 - def emit_regular; end - - # source://unparser//lib/unparser/anima.rb#146 - def local_variable_scope; end - - # source://unparser//lib/unparser/anima.rb#146 - def node; end - - private - - # source://unparser//lib/unparser/dsl.rb#18 - def assignment; end - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/writer/resbody.rb#32 - def emit_assignment; end - - # source://unparser//lib/unparser/writer/resbody.rb#25 - def emit_exception; end - - # source://unparser//lib/unparser/dsl.rb#18 - def exception; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - class << self - # source://unparser//lib/unparser/anima.rb#140 - def anima; end - end -end - -# source://unparser//lib/unparser/writer/rescue.rb#5 -class Unparser::Writer::Rescue - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - include ::Unparser::NodeHelpers - include ::Unparser::Generation - include ::Unparser::Writer - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - extend ::Unparser::DSL - - # source://unparser//lib/unparser/anima.rb#146 - def buffer; end - - # source://unparser//lib/unparser/anima.rb#146 - def comments; end - - # source://unparser//lib/unparser/writer/rescue.rb#23 - def emit_heredoc_reminders; end - - # source://unparser//lib/unparser/writer/rescue.rb#27 - def emit_postcontrol; end - - # source://unparser//lib/unparser/writer/rescue.rb#12 - def emit_regular; end - - # source://unparser//lib/unparser/anima.rb#146 - def local_variable_scope; end - - # source://unparser//lib/unparser/anima.rb#146 - def node; end - - private - - # source://unparser//lib/unparser/dsl.rb#18 - def body; end - - # source://unparser//lib/unparser/writer/rescue.rb#34 - def else_node; end - - # source://unparser//lib/unparser/writer/rescue.rb#38 - def emit_rescue_body(node); end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def rescue_bodies(&block); end - - # source://unparser//lib/unparser/dsl.rb#18 - def rescue_body; end - - class << self - # source://unparser//lib/unparser/anima.rb#140 - def anima; end - end -end - -# Writer for send -# -# source://unparser//lib/unparser/writer/send.rb#6 -class Unparser::Writer::Send - include ::Unparser::NodeHelpers - include ::Unparser::Generation - include ::Unparser::Constants - include ::Unparser::Adamantium - include ::Unparser::Adamantium::InstanceMethods - include ::Unparser::Writer - include ::Unparser::Anima::InstanceMethods - include ::Unparser::Equalizer::Methods - extend ::Unparser::Adamantium::ModuleMethods - extend ::Unparser::Adamantium::ClassMethods - extend ::Unparser::DSL - - # source://unparser//lib/unparser/anima.rb#146 - def buffer; end - - # source://unparser//lib/unparser/anima.rb#146 - def comments; end - - # source://unparser//lib/unparser/writer/send.rb#21 - def dispatch; end - - # source://unparser//lib/unparser/writer/send.rb#33 - def emit_heredoc_reminders; end - - # source://unparser//lib/unparser/writer/send.rb#25 - def emit_mlhs; end - - # source://unparser//lib/unparser/writer/send.rb#29 - def emit_selector; end - - # source://unparser//lib/unparser/anima.rb#146 - def local_variable_scope; end - - # source://unparser//lib/unparser/anima.rb#146 - def node; end - - private - - # source://unparser//lib/unparser/writer/send.rb#73 - def arguments; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/send.rb#85 - def avoid_clash?; end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def details(&block); end - - # source://unparser//lib/unparser/adamantium/method_builder.rb#87 - def effective_writer(&block); end - - # source://unparser//lib/unparser/writer/send.rb#45 - def effective_writer_class; end - - # source://unparser//lib/unparser/writer/send.rb#65 - def emit_arguments; end - - # source://unparser//lib/unparser/writer/send.rb#81 - def emit_heredoc_reminder(argument); end - - # source://unparser//lib/unparser/writer/send.rb#77 - def emit_normal_arguments; end - - # source://unparser//lib/unparser/writer/send.rb#61 - def emit_operator; end - - # source://unparser//lib/unparser/writer/send.rb#106 - def emit_send_regular(node); end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/send.rb#89 - def local_variable_clash?; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/send.rb#93 - def parses_as_constant?; end - - # source://unparser//lib/unparser/dsl.rb#18 - def receiver; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def selector; end - - # @return [Boolean] - # - # source://unparser//lib/unparser/writer/send.rb#57 - def write_as_attribute_assignment?; end - - class << self - # source://unparser//lib/unparser/anima.rb#140 - def anima; end - end -end - -# Writer for send as attribute assignment -# -# source://unparser//lib/unparser/writer/send/attribute_assignment.rb#7 -class Unparser::Writer::Send::AttributeAssignment < ::Unparser::Writer::Send - # source://unparser//lib/unparser/writer/send/attribute_assignment.rb#10 - def dispatch; end - - # source://unparser//lib/unparser/writer/send/attribute_assignment.rb#22 - def emit_send_mlhs; end - - private - - # source://unparser//lib/unparser/writer/send/attribute_assignment.rb#34 - def emit_attribute; end - - # source://unparser//lib/unparser/writer/send/attribute_assignment.rb#29 - def emit_receiver; end - - # source://unparser//lib/unparser/dsl.rb#18 - def first_argument; end - - # source://unparser//lib/unparser/dsl.rb#18 - def receiver; end - - # source://unparser//lib/unparser/dsl.rb#11 - def remaining_children; end - - # source://unparser//lib/unparser/dsl.rb#18 - def selector; end -end - -# Writer for binary sends -# -# source://unparser//lib/unparser/writer/send/binary.rb#7 -class Unparser::Writer::Send::Binary < ::Unparser::Writer::Send - # source://unparser//lib/unparser/writer/send/binary.rb#8 - def dispatch; end - - private - - # source://unparser//lib/unparser/writer/send/binary.rb#16 - def emit_operator; end - - # source://unparser//lib/unparser/writer/send/binary.rb#20 - def emit_right; end -end - -# source://unparser//lib/unparser/writer/send.rb#9 -Unparser::Writer::Send::INDEX_ASSIGN = T.let(T.unsafe(nil), Symbol) - -# source://unparser//lib/unparser/writer/send.rb#10 -Unparser::Writer::Send::INDEX_REFERENCE = T.let(T.unsafe(nil), Symbol) - -# source://unparser//lib/unparser/writer/send.rb#12 -Unparser::Writer::Send::OPERATORS = T.let(T.unsafe(nil), Hash) - -# Writer for "regular" receiver.selector(arguments...) case -# -# source://unparser//lib/unparser/writer/send/regular.rb#7 -class Unparser::Writer::Send::Regular < ::Unparser::Writer::Send - # source://unparser//lib/unparser/writer/send/regular.rb#8 - def dispatch; end - - # source://unparser//lib/unparser/writer/send/regular.rb#18 - def emit_arguments_without_heredoc_body; end - - # source://unparser//lib/unparser/writer/send/regular.rb#22 - def emit_receiver; end - - # source://unparser//lib/unparser/writer/send/regular.rb#14 - def emit_send_mlhs; end -end - -# Writer for unary sends -# -# source://unparser//lib/unparser/writer/send/unary.rb#7 -class Unparser::Writer::Send::Unary < ::Unparser::Writer::Send - # source://unparser//lib/unparser/writer/send/unary.rb#15 - def dispatch; end -end - -# source://unparser//lib/unparser/writer/send/unary.rb#8 -Unparser::Writer::Send::Unary::MAP = T.let(T.unsafe(nil), Hash) diff --git a/sorbet/rbi/gems/webrick@1.7.0.rbi b/sorbet/rbi/gems/webrick@1.7.0.rbi deleted file mode 100644 index ec98e78f..00000000 --- a/sorbet/rbi/gems/webrick@1.7.0.rbi +++ /dev/null @@ -1,2555 +0,0 @@ -# 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`. - -# AccessLog provides logging to various files in various formats. -# -# Multiple logs may be written to at the same time: -# -# access_log = [ -# [$stderr, WEBrick::AccessLog::COMMON_LOG_FORMAT], -# [$stderr, WEBrick::AccessLog::REFERER_LOG_FORMAT], -# ] -# -# server = WEBrick::HTTPServer.new :AccessLog => access_log -# -# Custom log formats may be defined. WEBrick::AccessLog provides a subset -# of the formatting from Apache's mod_log_config -# http://httpd.apache.org/docs/mod/mod_log_config.html#formats. See -# AccessLog::setup_params for a list of supported options -# -# source://webrick//lib/webrick/accesslog.rb#30 -module WEBrick::AccessLog - private - - # Escapes control characters in +data+ - # - # source://webrick//lib/webrick/accesslog.rb#151 - def escape(data); end - - # Formats +params+ according to +format_string+ which is described in - # setup_params. - # - # source://webrick//lib/webrick/accesslog.rb#123 - def format(format_string, params); end - - # This format specification is a subset of mod_log_config of Apache: - # - # %a:: Remote IP address - # %b:: Total response size - # %e{variable}:: Given variable in ENV - # %f:: Response filename - # %h:: Remote host name - # %{header}i:: Given request header - # %l:: Remote logname, always "-" - # %m:: Request method - # %{attr}n:: Given request attribute from req.attributes - # %{header}o:: Given response header - # %p:: Server's request port - # %{format}p:: The canonical port of the server serving the request or the - # actual port or the client's actual port. Valid formats are - # canonical, local or remote. - # %q:: Request query string - # %r:: First line of the request - # %s:: Request status - # %t:: Time the request was received - # %T:: Time taken to process the request - # %u:: Remote user from auth - # %U:: Unparsed URI - # %%:: Literal % - # - # source://webrick//lib/webrick/accesslog.rb#95 - def setup_params(config, req, res); end - - class << self - # Escapes control characters in +data+ - # - # source://webrick//lib/webrick/accesslog.rb#151 - def escape(data); end - - # Formats +params+ according to +format_string+ which is described in - # setup_params. - # - # source://webrick//lib/webrick/accesslog.rb#123 - def format(format_string, params); end - - # This format specification is a subset of mod_log_config of Apache: - # - # %a:: Remote IP address - # %b:: Total response size - # %e{variable}:: Given variable in ENV - # %f:: Response filename - # %h:: Remote host name - # %{header}i:: Given request header - # %l:: Remote logname, always "-" - # %m:: Request method - # %{attr}n:: Given request attribute from req.attributes - # %{header}o:: Given response header - # %p:: Server's request port - # %{format}p:: The canonical port of the server serving the request or the - # actual port or the client's actual port. Valid formats are - # canonical, local or remote. - # %q:: Request query string - # %r:: First line of the request - # %s:: Request status - # %t:: Time the request was received - # %T:: Time taken to process the request - # %u:: Remote user from auth - # %U:: Unparsed URI - # %%:: Literal % - # - # source://webrick//lib/webrick/accesslog.rb#95 - def setup_params(config, req, res); end - end -end - -# A generic logging class -# -# source://webrick//lib/webrick/log.rb#17 -class WEBrick::BasicLog - # Initializes a new logger for +log_file+ that outputs messages at +level+ - # or higher. +log_file+ can be a filename, an IO-like object that - # responds to #<< or nil which outputs to $stderr. - # - # If no level is given INFO is chosen by default - # - # @return [BasicLog] a new instance of BasicLog - # - # source://webrick//lib/webrick/log.rb#50 - def initialize(log_file = T.unsafe(nil), level = T.unsafe(nil)); end - - # Synonym for log(INFO, obj.to_s) - # - # source://webrick//lib/webrick/log.rb#84 - def <<(obj); end - - # Closes the logger (also closes the log device associated to the logger) - # - # source://webrick//lib/webrick/log.rb#66 - def close; end - - # Shortcut for logging a DEBUG message - # - # source://webrick//lib/webrick/log.rb#97 - def debug(msg); end - - # Will the logger output DEBUG messages? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/log.rb#108 - def debug?; end - - # Shortcut for logging an ERROR message - # - # source://webrick//lib/webrick/log.rb#91 - def error(msg); end - - # Will the logger output ERROR messages? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/log.rb#102 - def error?; end - - # Shortcut for logging a FATAL message - # - # source://webrick//lib/webrick/log.rb#89 - def fatal(msg); end - - # Will the logger output FATAL messages? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/log.rb#100 - def fatal?; end - - # Shortcut for logging an INFO message - # - # source://webrick//lib/webrick/log.rb#95 - def info(msg); end - - # Will the logger output INFO messages? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/log.rb#106 - def info?; end - - # log-level, messages above this level will be logged - # - # source://webrick//lib/webrick/log.rb#41 - def level; end - - # log-level, messages above this level will be logged - # - # source://webrick//lib/webrick/log.rb#41 - def level=(_arg0); end - - # Logs +data+ at +level+ if the given level is above the current log - # level. - # - # source://webrick//lib/webrick/log.rb#75 - def log(level, data); end - - # Shortcut for logging a WARN message - # - # source://webrick//lib/webrick/log.rb#93 - def warn(msg); end - - # Will the logger output WARN messages? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/log.rb#104 - def warn?; end - - private - - # Formats +arg+ for the logger - # - # * If +arg+ is an Exception, it will format the error message and - # the back trace. - # * If +arg+ responds to #to_str, it will return it. - # * Otherwise it will return +arg+.inspect. - # - # source://webrick//lib/webrick/log.rb#119 - def format(arg); end -end - -# -- -# Updates WEBrick::GenericServer with SSL functionality -# -# source://webrick//lib/webrick/server.rb#56 -class WEBrick::GenericServer - # Creates a new generic server from +config+. The default configuration - # comes from +default+. - # - # @return [GenericServer] a new instance of GenericServer - # - # source://webrick//lib/webrick/server.rb#88 - def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end - - # Retrieves +key+ from the configuration - # - # source://webrick//lib/webrick/server.rb#121 - def [](key); end - - # The server configuration - # - # source://webrick//lib/webrick/server.rb#66 - def config; end - - # Updates +listen+ to enable SSL when the SSL configuration is active. - # - # source://webrick//lib/webrick/server.rb#129 - def listen(address, port); end - - # Sockets listening for connections. - # - # source://webrick//lib/webrick/server.rb#82 - def listeners; end - - # The server logger. This is independent from the HTTP access log. - # - # source://webrick//lib/webrick/server.rb#71 - def logger; end - - # You must subclass GenericServer and implement \#run which accepts a TCP - # client socket - # - # source://webrick//lib/webrick/server.rb#244 - def run(sock); end - - # Shuts down the server and all listening sockets. New listeners must be - # provided to restart the server. - # - # source://webrick//lib/webrick/server.rb#234 - def shutdown; end - - # Starts the server and runs the +block+ for each connection. This method - # does not return until the server is stopped from a signal handler or - # another thread using #stop or #shutdown. - # - # If the block raises a subclass of StandardError the exception is logged - # and ignored. If an IOError or Errno::EBADF exception is raised the - # exception is ignored. If an Exception subclass is raised the exception - # is logged and re-raised which stops the server. - # - # To completely shut down a server call #shutdown from ensure: - # - # server = WEBrick::GenericServer.new - # # or WEBrick::HTTPServer.new - # - # begin - # server.start - # ensure - # server.shutdown - # end - # - # @raise [ServerError] - # - # source://webrick//lib/webrick/server.rb#154 - def start(&block); end - - # The server status. One of :Stop, :Running or :Shutdown - # - # source://webrick//lib/webrick/server.rb#61 - def status; end - - # Stops the server from accepting new connections. - # - # source://webrick//lib/webrick/server.rb#222 - def stop; end - - # Tokens control the number of outstanding clients. The - # :MaxClients configuration sets this. - # - # source://webrick//lib/webrick/server.rb#77 - def tokens; end - - private - - # Accepts a TCP client socket from the TCP server socket +svr+ and returns - # the client socket. - # - # source://webrick//lib/webrick/server.rb#256 - def accept_client(svr); end - - # source://webrick//lib/webrick/server.rb#347 - def alarm_shutdown_pipe; end - - # Calls the callback +callback_name+ from the configuration with +args+ - # - # source://webrick//lib/webrick/server.rb#334 - def call_callback(callback_name, *args); end - - # source://webrick//lib/webrick/server.rb#359 - def cleanup_listener; end - - # source://webrick//lib/webrick/server.rb#342 - def cleanup_shutdown_pipe(shutdown_pipe); end - - # source://webrick//lib/webrick/server.rb#338 - def setup_shutdown_pipe; end - - # Starts a server thread for the client socket +sock+ that runs the given - # +block+. - # - # Sets the socket to the :WEBrickSocket thread local variable - # in the thread. - # - # If any errors occur in the block they are logged and handled. - # - # source://webrick//lib/webrick/server.rb#288 - def start_thread(sock, &block); end -end - -# source://webrick//lib/webrick/htmlutils.rb#13 -module WEBrick::HTMLUtils - private - - # Escapes &, ", > and < in +string+ - # - # source://webrick//lib/webrick/htmlutils.rb#18 - def escape(string); end - - class << self - # Escapes &, ", > and < in +string+ - # - # source://webrick//lib/webrick/htmlutils.rb#18 - def escape(string); end - end -end - -# HTTPAuth provides both basic and digest authentication. -# -# To enable authentication for requests in WEBrick you will need a user -# database and an authenticator. To start, here's an Htpasswd database for -# use with a DigestAuth authenticator: -# -# config = { :Realm => 'DigestAuth example realm' } -# -# htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file' -# htpasswd.auth_type = WEBrick::HTTPAuth::DigestAuth -# htpasswd.set_passwd config[:Realm], 'username', 'password' -# htpasswd.flush -# -# The +:Realm+ is used to provide different access to different groups -# across several resources on a server. Typically you'll need only one -# realm for a server. -# -# This database can be used to create an authenticator: -# -# config[:UserDB] = htpasswd -# -# digest_auth = WEBrick::HTTPAuth::DigestAuth.new config -# -# To authenticate a request call #authenticate with a request and response -# object in a servlet: -# -# def do_GET req, res -# @authenticator.authenticate req, res -# end -# -# For digest authentication the authenticator must not be created every -# request, it must be passed in as an option via WEBrick::HTTPServer#mount. -# -# source://webrick//lib/webrick/httpauth/authenticator.rb#12 -module WEBrick::HTTPAuth - private - - # source://webrick//lib/webrick/httpauth.rb#57 - def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end - - # Simple wrapper for providing basic authentication for a request. When - # called with a request +req+, response +res+, authentication +realm+ and - # +block+ the block will be called with a +username+ and +password+. If - # the block returns true the request is allowed to continue, otherwise an - # HTTPStatus::Unauthorized error is raised. - # - # source://webrick//lib/webrick/httpauth.rb#79 - def basic_auth(req, res, realm, &block); end - - # Simple wrapper for providing basic authentication for a proxied request. - # When called with a request +req+, response +res+, authentication +realm+ - # and +block+ the block will be called with a +username+ and +password+. - # If the block returns true the request is allowed to continue, otherwise - # an HTTPStatus::ProxyAuthenticationRequired error is raised. - # - # source://webrick//lib/webrick/httpauth.rb#91 - def proxy_basic_auth(req, res, realm, &block); end - - class << self - # source://webrick//lib/webrick/httpauth.rb#57 - def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end - - # Simple wrapper for providing basic authentication for a request. When - # called with a request +req+, response +res+, authentication +realm+ and - # +block+ the block will be called with a +username+ and +password+. If - # the block returns true the request is allowed to continue, otherwise an - # HTTPStatus::Unauthorized error is raised. - # - # source://webrick//lib/webrick/httpauth.rb#79 - def basic_auth(req, res, realm, &block); end - - # Simple wrapper for providing basic authentication for a proxied request. - # When called with a request +req+, response +res+, authentication +realm+ - # and +block+ the block will be called with a +username+ and +password+. - # If the block returns true the request is allowed to continue, otherwise - # an HTTPStatus::ProxyAuthenticationRequired error is raised. - # - # source://webrick//lib/webrick/httpauth.rb#91 - def proxy_basic_auth(req, res, realm, &block); end - end -end - -# Module providing generic support for both Digest and Basic -# authentication schemes. -# -# source://webrick//lib/webrick/httpauth/authenticator.rb#18 -module WEBrick::HTTPAuth::Authenticator - # The logger for this authenticator - # - # source://webrick//lib/webrick/httpauth/authenticator.rb#43 - def logger; end - - # The realm this authenticator covers - # - # source://webrick//lib/webrick/httpauth/authenticator.rb#33 - def realm; end - - # The user database for this authenticator - # - # source://webrick//lib/webrick/httpauth/authenticator.rb#38 - def userdb; end - - private - - # Initializes the authenticator from +config+ - # - # source://webrick//lib/webrick/httpauth/authenticator.rb#52 - def check_init(config); end - - # Ensures +req+ has credentials that can be authenticated. - # - # source://webrick//lib/webrick/httpauth/authenticator.rb#72 - def check_scheme(req); end - - # source://webrick//lib/webrick/httpauth/authenticator.rb#91 - def error(fmt, *args); end - - # source://webrick//lib/webrick/httpauth/authenticator.rb#97 - def info(fmt, *args); end - - # source://webrick//lib/webrick/httpauth/authenticator.rb#85 - def log(meth, fmt, *args); end -end - -# source://webrick//lib/webrick/httpauth/authenticator.rb#23 -WEBrick::HTTPAuth::Authenticator::AuthException = WEBrick::HTTPStatus::Unauthorized - -# Basic Authentication for WEBrick -# -# Use this class to add basic authentication to a WEBrick servlet. -# -# Here is an example of how to set up a BasicAuth: -# -# config = { :Realm => 'BasicAuth example realm' } -# -# htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file', password_hash: :bcrypt -# htpasswd.set_passwd config[:Realm], 'username', 'password' -# htpasswd.flush -# -# config[:UserDB] = htpasswd -# -# basic_auth = WEBrick::HTTPAuth::BasicAuth.new config -# -# source://webrick//lib/webrick/httpauth/basicauth.rb#35 -class WEBrick::HTTPAuth::BasicAuth - include ::WEBrick::HTTPAuth::Authenticator - - # Creates a new BasicAuth instance. - # - # See WEBrick::Config::BasicAuth for default configuration entries - # - # You must supply the following configuration entries: - # - # :Realm:: The name of the realm being protected. - # :UserDB:: A database of usernames and passwords. - # A WEBrick::HTTPAuth::Htpasswd instance should be used. - # - # @return [BasicAuth] a new instance of BasicAuth - # - # source://webrick//lib/webrick/httpauth/basicauth.rb#61 - def initialize(config, default = T.unsafe(nil)); end - - # Authenticates a +req+ and returns a 401 Unauthorized using +res+ if - # the authentication was not correct. - # - # source://webrick//lib/webrick/httpauth/basicauth.rb#70 - def authenticate(req, res); end - - # Returns a challenge response which asks for authentication information - # - # @raise [@auth_exception] - # - # source://webrick//lib/webrick/httpauth/basicauth.rb#103 - def challenge(req, res); end - - # Returns the value of attribute logger. - # - # source://webrick//lib/webrick/httpauth/basicauth.rb#48 - def logger; end - - # Returns the value of attribute realm. - # - # source://webrick//lib/webrick/httpauth/basicauth.rb#48 - def realm; end - - # Returns the value of attribute userdb. - # - # source://webrick//lib/webrick/httpauth/basicauth.rb#48 - def userdb; end - - class << self - # Used by UserDB to create a basic password entry - # - # source://webrick//lib/webrick/httpauth/basicauth.rb#43 - def make_passwd(realm, user, pass); end - end -end - -# RFC 2617 Digest Access Authentication for WEBrick -# -# Use this class to add digest authentication to a WEBrick servlet. -# -# Here is an example of how to set up DigestAuth: -# -# config = { :Realm => 'DigestAuth example realm' } -# -# htdigest = WEBrick::HTTPAuth::Htdigest.new 'my_password_file' -# htdigest.set_passwd config[:Realm], 'username', 'password' -# htdigest.flush -# -# config[:UserDB] = htdigest -# -# digest_auth = WEBrick::HTTPAuth::DigestAuth.new config -# -# When using this as with a servlet be sure not to create a new DigestAuth -# object in the servlet's #initialize. By default WEBrick creates a new -# servlet instance for every request and the DigestAuth object must be -# used across requests. -# -# source://webrick//lib/webrick/httpauth/digestauth.rb#46 -class WEBrick::HTTPAuth::DigestAuth - include ::WEBrick::HTTPAuth::Authenticator - - # Creates a new DigestAuth instance. Be sure to use the same DigestAuth - # instance for multiple requests as it saves state between requests in - # order to perform authentication. - # - # See WEBrick::Config::DigestAuth for default configuration entries - # - # You must supply the following configuration entries: - # - # :Realm:: The name of the realm being protected. - # :UserDB:: A database of usernames and passwords. - # A WEBrick::HTTPAuth::Htdigest instance should be used. - # - # @return [DigestAuth] a new instance of DigestAuth - # - # source://webrick//lib/webrick/httpauth/digestauth.rb#87 - def initialize(config, default = T.unsafe(nil)); end - - # Digest authentication algorithm - # - # source://webrick//lib/webrick/httpauth/digestauth.rb#59 - def algorithm; end - - # Authenticates a +req+ and returns a 401 Unauthorized using +res+ if - # the authentication was not correct. - # - # source://webrick//lib/webrick/httpauth/digestauth.rb#121 - def authenticate(req, res); end - - # Returns a challenge response which asks for authentication information - # - # @raise [@auth_exception] - # - # source://webrick//lib/webrick/httpauth/digestauth.rb#134 - def challenge(req, res, stale = T.unsafe(nil)); end - - # Quality of protection. RFC 2617 defines "auth" and "auth-int" - # - # source://webrick//lib/webrick/httpauth/digestauth.rb#64 - def qop; end - - private - - # source://webrick//lib/webrick/httpauth/digestauth.rb#163 - def _authenticate(req, res); end - - # source://webrick//lib/webrick/httpauth/digestauth.rb#306 - def check_nonce(req, auth_req); end - - # source://webrick//lib/webrick/httpauth/digestauth.rb#349 - def check_opaque(opaque_struct, req, auth_req); end - - # source://webrick//lib/webrick/httpauth/digestauth.rb#365 - def check_uri(req, auth_req); end - - # source://webrick//lib/webrick/httpauth/digestauth.rb#299 - def generate_next_nonce(req); end - - # source://webrick//lib/webrick/httpauth/digestauth.rb#332 - def generate_opaque(req); end - - # source://webrick//lib/webrick/httpauth/digestauth.rb#376 - def hexdigest(*args); end - - # source://webrick//lib/webrick/httpauth/digestauth.rb#291 - def split_param_value(string); end - - class << self - # Used by UserDB to create a digest password entry - # - # source://webrick//lib/webrick/httpauth/digestauth.rb#69 - def make_passwd(realm, user, pass); end - end -end - -# Htdigest accesses apache-compatible digest password files. Passwords are -# matched to a realm where they are valid. For security, the path for a -# digest password database should be stored outside of the paths available -# to the HTTP server. -# -# Htdigest is intended for use with WEBrick::HTTPAuth::DigestAuth and -# stores passwords using cryptographic hashes. -# -# htpasswd = WEBrick::HTTPAuth::Htdigest.new 'my_password_file' -# htpasswd.set_passwd 'my realm', 'username', 'password' -# htpasswd.flush -# -# source://webrick//lib/webrick/httpauth/htdigest.rb#31 -class WEBrick::HTTPAuth::Htdigest - include ::WEBrick::HTTPAuth::UserDB - - # Open a digest password database at +path+ - # - # @return [Htdigest] a new instance of Htdigest - # - # source://webrick//lib/webrick/httpauth/htdigest.rb#37 - def initialize(path); end - - # Removes a password from the database for +user+ in +realm+. - # - # source://webrick//lib/webrick/httpauth/htdigest.rb#113 - def delete_passwd(realm, user); end - - # Iterate passwords in the database. - # - # source://webrick//lib/webrick/httpauth/htdigest.rb#122 - def each; end - - # Flush the password database. If +output+ is given the database will - # be written there instead of to the original path. - # - # source://webrick//lib/webrick/httpauth/htdigest.rb#72 - def flush(output = T.unsafe(nil)); end - - # Retrieves a password from the database for +user+ in +realm+. If - # +reload_db+ is true the database will be reloaded first. - # - # source://webrick//lib/webrick/httpauth/htdigest.rb#91 - def get_passwd(realm, user, reload_db); end - - # Reloads passwords from the database - # - # source://webrick//lib/webrick/httpauth/htdigest.rb#50 - def reload; end - - # Sets a password in the database for +user+ in +realm+ to +pass+. - # - # source://webrick//lib/webrick/httpauth/htdigest.rb#101 - def set_passwd(realm, user, pass); end -end - -# Htgroup accesses apache-compatible group files. Htgroup can be used to -# provide group-based authentication for users. Currently Htgroup is not -# directly integrated with any authenticators in WEBrick. For security, -# the path for a digest password database should be stored outside of the -# paths available to the HTTP server. -# -# Example: -# -# htgroup = WEBrick::HTTPAuth::Htgroup.new 'my_group_file' -# htgroup.add 'superheroes', %w[spiderman batman] -# -# htgroup.members('superheroes').include? 'magneto' # => false -# -# source://webrick//lib/webrick/httpauth/htgroup.rb#30 -class WEBrick::HTTPAuth::Htgroup - # Open a group database at +path+ - # - # @return [Htgroup] a new instance of Htgroup - # - # source://webrick//lib/webrick/httpauth/htgroup.rb#35 - def initialize(path); end - - # Add an Array of +members+ to +group+ - # - # source://webrick//lib/webrick/httpauth/htgroup.rb#92 - def add(group, members); end - - # Flush the group database. If +output+ is given the database will be - # written there instead of to the original path. - # - # source://webrick//lib/webrick/httpauth/htgroup.rb#64 - def flush(output = T.unsafe(nil)); end - - # Retrieve the list of members from +group+ - # - # source://webrick//lib/webrick/httpauth/htgroup.rb#84 - def members(group); end - - # Reload groups from the database - # - # source://webrick//lib/webrick/httpauth/htgroup.rb#46 - def reload; end -end - -# Htpasswd accesses apache-compatible password files. Passwords are -# matched to a realm where they are valid. For security, the path for a -# password database should be stored outside of the paths available to the -# HTTP server. -# -# Htpasswd is intended for use with WEBrick::HTTPAuth::BasicAuth. -# -# To create an Htpasswd database with a single user: -# -# htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file' -# htpasswd.set_passwd 'my realm', 'username', 'password' -# htpasswd.flush -# -# source://webrick//lib/webrick/httpauth/htpasswd.rb#32 -class WEBrick::HTTPAuth::Htpasswd - include ::WEBrick::HTTPAuth::UserDB - - # Open a password database at +path+ - # - # @return [Htpasswd] a new instance of Htpasswd - # - # source://webrick//lib/webrick/httpauth/htpasswd.rb#38 - def initialize(path, password_hash: T.unsafe(nil)); end - - # Removes a password from the database for +user+ in +realm+. - # - # source://webrick//lib/webrick/httpauth/htpasswd.rb#144 - def delete_passwd(realm, user); end - - # Iterate passwords in the database. - # - # source://webrick//lib/webrick/httpauth/htpasswd.rb#151 - def each; end - - # Flush the password database. If +output+ is given the database will - # be written there instead of to the original path. - # - # source://webrick//lib/webrick/httpauth/htpasswd.rb#103 - def flush(output = T.unsafe(nil)); end - - # Retrieves a password from the database for +user+ in +realm+. If - # +reload_db+ is true the database will be reloaded first. - # - # source://webrick//lib/webrick/httpauth/htpasswd.rb#122 - def get_passwd(realm, user, reload_db); end - - # Reload passwords from the database - # - # source://webrick//lib/webrick/httpauth/htpasswd.rb#68 - def reload; end - - # Sets a password in the database for +user+ in +realm+ to +pass+. - # - # source://webrick//lib/webrick/httpauth/htpasswd.rb#130 - def set_passwd(realm, user, pass); end -end - -# source://webrick//lib/webrick/httpauth/authenticator.rb#114 -WEBrick::HTTPAuth::ProxyAuthenticator::AuthException = WEBrick::HTTPStatus::ProxyAuthenticationRequired - -# Basic authentication for proxy servers. See BasicAuth for details. -# -# source://webrick//lib/webrick/httpauth/basicauth.rb#112 -class WEBrick::HTTPAuth::ProxyBasicAuth < ::WEBrick::HTTPAuth::BasicAuth - include ::WEBrick::HTTPAuth::ProxyAuthenticator -end - -# Digest authentication for proxy servers. See DigestAuth for details. -# -# source://webrick//lib/webrick/httpauth/digestauth.rb#386 -class WEBrick::HTTPAuth::ProxyDigestAuth < ::WEBrick::HTTPAuth::DigestAuth - include ::WEBrick::HTTPAuth::ProxyAuthenticator - - private - - # source://webrick//lib/webrick/httpauth/digestauth.rb#390 - def check_uri(req, auth_req); end -end - -# User database mixin for HTTPAuth. This mixin dispatches user record -# access to the underlying auth_type for this database. -# -# source://webrick//lib/webrick/httpauth/userdb.rb#18 -module WEBrick::HTTPAuth::UserDB - # The authentication type. - # - # WEBrick::HTTPAuth::BasicAuth or WEBrick::HTTPAuth::DigestAuth are - # built-in. - # - # source://webrick//lib/webrick/httpauth/userdb.rb#26 - def auth_type; end - - # The authentication type. - # - # WEBrick::HTTPAuth::BasicAuth or WEBrick::HTTPAuth::DigestAuth are - # built-in. - # - # source://webrick//lib/webrick/httpauth/userdb.rb#26 - def auth_type=(_arg0); end - - # Retrieves a password in +realm+ for +user+ for the auth_type of this - # database. +reload_db+ is a dummy value. - # - # source://webrick//lib/webrick/httpauth/userdb.rb#48 - def get_passwd(realm, user, reload_db = T.unsafe(nil)); end - - # Creates an obscured password in +realm+ with +user+ and +password+ - # using the auth_type of this database. - # - # source://webrick//lib/webrick/httpauth/userdb.rb#32 - def make_passwd(realm, user, pass); end - - # Sets a password in +realm+ with +user+ and +password+ for the - # auth_type of this database. - # - # source://webrick//lib/webrick/httpauth/userdb.rb#40 - def set_passwd(realm, user, pass); end -end - -# -- -# Adds SSL functionality to WEBrick::HTTPRequest -# -# source://webrick//lib/webrick/httprequest.rb#25 -class WEBrick::HTTPRequest - # Creates a new HTTP request. WEBrick::Config::HTTP is the default - # configuration. - # - # @return [HTTPRequest] a new instance of HTTPRequest - # - # source://webrick//lib/webrick/httprequest.rb#153 - def initialize(config); end - - # Retrieves +header_name+ - # - # source://webrick//lib/webrick/httprequest.rb#318 - def [](header_name); end - - # The Accept header value - # - # source://webrick//lib/webrick/httprequest.rb#100 - def accept; end - - # The Accept-Charset header value - # - # source://webrick//lib/webrick/httprequest.rb#105 - def accept_charset; end - - # The Accept-Encoding header value - # - # source://webrick//lib/webrick/httprequest.rb#110 - def accept_encoding; end - - # The Accept-Language header value - # - # source://webrick//lib/webrick/httprequest.rb#115 - def accept_language; end - - # The socket address of the server - # - # source://webrick//lib/webrick/httprequest.rb#127 - def addr; end - - # Hash of request attributes - # - # source://webrick//lib/webrick/httprequest.rb#137 - def attributes; end - - # Returns the request body. - # - # source://webrick//lib/webrick/httprequest.rb#255 - def body(&block); end - - # Prepares the HTTPRequest object for use as the - # source for IO.copy_stream - # - # source://webrick//lib/webrick/httprequest.rb#265 - def body_reader; end - - # The content-length header - # - # source://webrick//lib/webrick/httprequest.rb#304 - def content_length; end - - # The content-type header - # - # source://webrick//lib/webrick/httprequest.rb#311 - def content_type; end - - # Generate HTTP/1.1 100 continue response if the client expects it, - # otherwise does nothing. - # - # source://webrick//lib/webrick/httprequest.rb#245 - def continue; end - - # The parsed request cookies - # - # source://webrick//lib/webrick/httprequest.rb#95 - def cookies; end - - # Iterates over the request headers - # - # source://webrick//lib/webrick/httprequest.rb#328 - def each; end - - # Consumes any remaining body and updates keep-alive status - # - # source://webrick//lib/webrick/httprequest.rb#390 - def fixup; end - - # The parsed header of the request - # - # source://webrick//lib/webrick/httprequest.rb#90 - def header; end - - # The host this request is for - # - # source://webrick//lib/webrick/httprequest.rb#340 - def host; end - - # The HTTP version of the request - # - # source://webrick//lib/webrick/httprequest.rb#51 - def http_version; end - - # Is this a keep-alive connection? - # - # source://webrick//lib/webrick/httprequest.rb#142 - def keep_alive; end - - # Should the connection this request was made on be kept alive? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httprequest.rb#375 - def keep_alive?; end - - # This method provides the metavariables defined by the revision 3 - # of "The WWW Common Gateway Interface Version 1.1" - # To browse the current document of CGI Version 1.1, see below: - # http://tools.ietf.org/html/rfc3875 - # - # source://webrick//lib/webrick/httprequest.rb#407 - def meta_vars; end - - # Parses a request from +socket+. This is called internally by - # WEBrick::HTTPServer. - # - # source://webrick//lib/webrick/httprequest.rb#193 - def parse(socket = T.unsafe(nil)); end - - # The request path - # - # source://webrick//lib/webrick/httprequest.rb#63 - def path; end - - # The path info (CGI variable) - # - # source://webrick//lib/webrick/httprequest.rb#73 - def path_info; end - - # The path info (CGI variable) - # - # source://webrick//lib/webrick/httprequest.rb#73 - def path_info=(_arg0); end - - # The socket address of the client - # - # source://webrick//lib/webrick/httprequest.rb#132 - def peeraddr; end - - # The port this request is for - # - # source://webrick//lib/webrick/httprequest.rb#347 - def port; end - - # Request query as a Hash - # - # source://webrick//lib/webrick/httprequest.rb#294 - def query; end - - # The query from the URI of the request - # - # source://webrick//lib/webrick/httprequest.rb#78 - def query_string; end - - # The query from the URI of the request - # - # source://webrick//lib/webrick/httprequest.rb#78 - def query_string=(_arg0); end - - # The raw header of the request - # - # source://webrick//lib/webrick/httprequest.rb#85 - def raw_header; end - - # for IO.copy_stream. - # - # source://webrick//lib/webrick/httprequest.rb#278 - def readpartial(size, buf = T.unsafe(nil)); end - - # The client's IP address - # - # source://webrick//lib/webrick/httprequest.rb#361 - def remote_ip; end - - # The complete request line such as: - # - # GET / HTTP/1.1 - # - # source://webrick//lib/webrick/httprequest.rb#36 - def request_line; end - - # The request method, GET, POST, PUT, etc. - # - # source://webrick//lib/webrick/httprequest.rb#41 - def request_method; end - - # The local time this request was received - # - # source://webrick//lib/webrick/httprequest.rb#147 - def request_time; end - - # The parsed URI of the request - # - # source://webrick//lib/webrick/httprequest.rb#58 - def request_uri; end - - # The script name (CGI variable) - # - # source://webrick//lib/webrick/httprequest.rb#68 - def script_name; end - - # The script name (CGI variable) - # - # source://webrick//lib/webrick/httprequest.rb#68 - def script_name=(_arg0); end - - # The server name this request is for - # - # source://webrick//lib/webrick/httprequest.rb#354 - def server_name; end - - # Is this an SSL request? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httprequest.rb#368 - def ssl?; end - - # source://webrick//lib/webrick/httprequest.rb#379 - def to_s; end - - # The unparsed URI of the request - # - # source://webrick//lib/webrick/httprequest.rb#46 - def unparsed_uri; end - - # The remote user (CGI variable) - # - # source://webrick//lib/webrick/httprequest.rb#122 - def user; end - - # The remote user (CGI variable) - # - # source://webrick//lib/webrick/httprequest.rb#122 - def user=(_arg0); end - - private - - # source://webrick//lib/webrick/httprequest.rb#562 - def _read_data(io, method, *arg); end - - # source://webrick//lib/webrick/httprequest.rb#582 - def parse_query; end - - # source://webrick//lib/webrick/httprequest.rb#484 - def parse_uri(str, scheme = T.unsafe(nil)); end - - # source://webrick//lib/webrick/httprequest.rb#507 - def read_body(socket, block); end - - # source://webrick//lib/webrick/httprequest.rb#531 - def read_chunk_size(socket); end - - # source://webrick//lib/webrick/httprequest.rb#542 - def read_chunked(socket, block); end - - # source://webrick//lib/webrick/httprequest.rb#578 - def read_data(io, size); end - - # source://webrick//lib/webrick/httprequest.rb#471 - def read_header(socket); end - - # source://webrick//lib/webrick/httprequest.rb#574 - def read_line(io, size = T.unsafe(nil)); end - - # @raise [HTTPStatus::EOFError] - # - # source://webrick//lib/webrick/httprequest.rb#451 - def read_request_line(socket); end - - # It's said that all X-Forwarded-* headers will contain more than one - # (comma-separated) value if the original request already contained one of - # these headers. Since we could use these values as Host header, we choose - # the initial(first) value. (apr_table_mergen() adds new value after the - # existing value with ", " prefix) - # - # source://webrick//lib/webrick/httprequest.rb#610 - def setup_forwarded_info; end -end - -# same as Mongrel, Thin and Puma -# -# source://webrick//lib/webrick/httprequest.rb#449 -WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer) - -# An HTTP response. This is filled in by the service or do_* methods of a -# WEBrick HTTP Servlet. -# -# source://webrick//lib/webrick/httpresponse.rb#24 -class WEBrick::HTTPResponse - # Creates a new HTTP response object. WEBrick::Config::HTTP is the - # default configuration. - # - # @return [HTTPResponse] a new instance of HTTPResponse - # - # source://webrick//lib/webrick/httpresponse.rb#112 - def initialize(config); end - - # Retrieves the response header +field+ - # - # source://webrick//lib/webrick/httpresponse.rb#150 - def [](field); end - - # Sets the response header +field+ to +value+ - # - # source://webrick//lib/webrick/httpresponse.rb#157 - def []=(field, value); end - - # Body may be: - # * a String; - # * an IO-like object that responds to +#read+ and +#readpartial+; - # * a Proc-like object that responds to +#call+. - # - # In the latter case, either #chunked= should be set to +true+, - # or header['content-length'] explicitly provided. - # Example: - # - # server.mount_proc '/' do |req, res| - # res.chunked = true - # # or - # # res.header['content-length'] = 10 - # res.body = proc { |out| out.write(Time.now.to_s) } - # end - # - # source://webrick//lib/webrick/httpresponse.rb#70 - def body; end - - # Body may be: - # * a String; - # * an IO-like object that responds to +#read+ and +#readpartial+; - # * a Proc-like object that responds to +#call+. - # - # In the latter case, either #chunked= should be set to +true+, - # or header['content-length'] explicitly provided. - # Example: - # - # server.mount_proc '/' do |req, res| - # res.chunked = true - # # or - # # res.header['content-length'] = 10 - # res.body = proc { |out| out.write(Time.now.to_s) } - # end - # - # source://webrick//lib/webrick/httpresponse.rb#70 - def body=(_arg0); end - - # Enables chunked transfer encoding. - # - # source://webrick//lib/webrick/httpresponse.rb#209 - def chunked=(val); end - - # Will this response body be returned using chunked transfer-encoding? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpresponse.rb#202 - def chunked?; end - - # Configuration for this response - # - # source://webrick//lib/webrick/httpresponse.rb#101 - def config; end - - # The content-length header - # - # source://webrick//lib/webrick/httpresponse.rb#165 - def content_length; end - - # Sets the content-length header to +len+ - # - # source://webrick//lib/webrick/httpresponse.rb#174 - def content_length=(len); end - - # The content-type header - # - # source://webrick//lib/webrick/httpresponse.rb#181 - def content_type; end - - # Sets the content-type header to +type+ - # - # source://webrick//lib/webrick/httpresponse.rb#188 - def content_type=(type); end - - # Response cookies - # - # source://webrick//lib/webrick/httpresponse.rb#46 - def cookies; end - - # Iterates over each header in the response - # - # source://webrick//lib/webrick/httpresponse.rb#195 - def each; end - - # Filename of the static file in this response. Only used by the - # FileHandler servlet. - # - # source://webrick//lib/webrick/httpresponse.rb#91 - def filename; end - - # Filename of the static file in this response. Only used by the - # FileHandler servlet. - # - # source://webrick//lib/webrick/httpresponse.rb#91 - def filename=(_arg0); end - - # Response header - # - # source://webrick//lib/webrick/httpresponse.rb#41 - def header; end - - # HTTP Response version - # - # source://webrick//lib/webrick/httpresponse.rb#31 - def http_version; end - - # Is this a keep-alive response? - # - # source://webrick//lib/webrick/httpresponse.rb#96 - def keep_alive; end - - # Is this a keep-alive response? - # - # source://webrick//lib/webrick/httpresponse.rb#96 - def keep_alive=(_arg0); end - - # Will this response's connection be kept alive? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpresponse.rb#216 - def keep_alive?; end - - # source://webrick//lib/webrick/httpresponse.rb#303 - def make_body_tempfile; end - - # Response reason phrase ("OK") - # - # source://webrick//lib/webrick/httpresponse.rb#51 - def reason_phrase; end - - # Response reason phrase ("OK") - # - # source://webrick//lib/webrick/httpresponse.rb#51 - def reason_phrase=(_arg0); end - - # source://webrick//lib/webrick/httpresponse.rb#321 - def remove_body_tempfile; end - - # Request HTTP version for this response - # - # source://webrick//lib/webrick/httpresponse.rb#85 - def request_http_version; end - - # Request HTTP version for this response - # - # source://webrick//lib/webrick/httpresponse.rb#85 - def request_http_version=(_arg0); end - - # Request method for this response - # - # source://webrick//lib/webrick/httpresponse.rb#75 - def request_method; end - - # Request method for this response - # - # source://webrick//lib/webrick/httpresponse.rb#75 - def request_method=(_arg0); end - - # Request URI for this response - # - # source://webrick//lib/webrick/httpresponse.rb#80 - def request_uri; end - - # Request URI for this response - # - # source://webrick//lib/webrick/httpresponse.rb#80 - def request_uri=(_arg0); end - - # Sends the body on +socket+ - # - # source://webrick//lib/webrick/httpresponse.rb#356 - def send_body(socket); end - - # Sends the headers on +socket+ - # - # source://webrick//lib/webrick/httpresponse.rb#333 - def send_header(socket); end - - # Sends the response on +socket+ - # - # source://webrick//lib/webrick/httpresponse.rb#223 - def send_response(socket); end - - # Bytes sent in this response - # - # source://webrick//lib/webrick/httpresponse.rb#106 - def sent_size; end - - # Creates an error page for exception +ex+ with an optional +backtrace+ - # - # source://webrick//lib/webrick/httpresponse.rb#383 - def set_error(ex, backtrace = T.unsafe(nil)); end - - # Redirects to +url+ with a WEBrick::HTTPStatus::Redirect +status+. - # - # Example: - # - # res.set_redirect WEBrick::HTTPStatus::TemporaryRedirect - # - # source://webrick//lib/webrick/httpresponse.rb#373 - def set_redirect(status, url); end - - # Sets up the headers for sending - # - # source://webrick//lib/webrick/httpresponse.rb#240 - def setup_header; end - - # Response status code (200) - # - # source://webrick//lib/webrick/httpresponse.rb#36 - def status; end - - # Sets the response's status to the +status+ code - # - # source://webrick//lib/webrick/httpresponse.rb#142 - def status=(status); end - - # The response's HTTP status line - # - # source://webrick//lib/webrick/httpresponse.rb#135 - def status_line; end - - private - - # preserved for compatibility with some 3rd-party handlers - # - # source://webrick//lib/webrick/httpresponse.rb#557 - def _write_data(socket, data); end - - # source://webrick//lib/webrick/httpresponse.rb#410 - def check_header(header_value); end - - # :stopdoc: - # - # source://webrick//lib/webrick/httpresponse.rb#421 - def error_body(backtrace, ex, host, port); end - - # source://webrick//lib/webrick/httpresponse.rb#451 - def send_body_io(socket); end - - # source://webrick//lib/webrick/httpresponse.rb#513 - def send_body_proc(socket); end - - # source://webrick//lib/webrick/httpresponse.rb#491 - def send_body_string(socket); end -end - -# source://webrick//lib/webrick/httpresponse.rb#531 -class WEBrick::HTTPResponse::ChunkedWrapper - # @return [ChunkedWrapper] a new instance of ChunkedWrapper - # - # source://webrick//lib/webrick/httpresponse.rb#532 - def initialize(socket, resp); end - - # source://webrick//lib/webrick/httpresponse.rb#550 - def <<(*buf); end - - # source://webrick//lib/webrick/httpresponse.rb#537 - def write(buf); end -end - -# An HTTP Server -# -# source://webrick//lib/webrick/httpserver.rb#44 -class WEBrick::HTTPServer < ::WEBrick::GenericServer - # Creates a new HTTP server according to +config+ - # - # An HTTP server uses the following attributes: - # - # :AccessLog:: An array of access logs. See WEBrick::AccessLog - # :BindAddress:: Local address for the server to bind to - # :DocumentRoot:: Root path to serve files from - # :DocumentRootOptions:: Options for the default HTTPServlet::FileHandler - # :HTTPVersion:: The HTTP version of this server - # :Port:: Port to listen on - # :RequestCallback:: Called with a request and response before each - # request is serviced. - # :RequestTimeout:: Maximum time to wait between requests - # :ServerAlias:: Array of alternate names for this server for virtual - # hosting - # :ServerName:: Name for this server for virtual hosting - # - # @return [HTTPServer] a new instance of HTTPServer - # - # source://webrick//lib/webrick/httpserver.rb#46 - def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end - - # Logs +req+ and +res+ in the access logs. +config+ is used for the - # server name. - # - # source://webrick//lib/webrick/httpserver.rb#220 - def access_log(config, req, res); end - - # Creates the HTTPRequest used when handling the HTTP - # request. Can be overridden by subclasses. - # - # source://webrick//lib/webrick/httpserver.rb#230 - def create_request(with_webrick_config); end - - # Creates the HTTPResponse used when handling the HTTP - # request. Can be overridden by subclasses. - # - # source://webrick//lib/webrick/httpserver.rb#237 - def create_response(with_webrick_config); end - - # The default OPTIONS request handler says GET, HEAD, POST and OPTIONS - # requests are allowed. - # - # source://webrick//lib/webrick/httpserver.rb#147 - def do_OPTIONS(req, res); end - - # Finds the appropriate virtual host to handle +req+ - # - # source://webrick//lib/webrick/httpserver.rb#207 - def lookup_server(req); end - - # Mounts +servlet+ on +dir+ passing +options+ to the servlet at creation - # time - # - # source://webrick//lib/webrick/httpserver.rb#155 - def mount(dir, servlet, *options); end - - # Mounts +proc+ or +block+ on +dir+ and calls it with a - # WEBrick::HTTPRequest and WEBrick::HTTPResponse - # - # @raise [HTTPServerError] - # - # source://webrick//lib/webrick/httpserver.rb#164 - def mount_proc(dir, proc = T.unsafe(nil), &block); end - - # Processes requests on +sock+ - # - # source://webrick//lib/webrick/httpserver.rb#69 - def run(sock); end - - # Finds a servlet for +path+ - # - # source://webrick//lib/webrick/httpserver.rb#182 - def search_servlet(path); end - - # Services +req+ and fills in +res+ - # - # @raise [HTTPStatus::NotFound] - # - # source://webrick//lib/webrick/httpserver.rb#125 - def service(req, res); end - - # Unmounts +dir+ - # - # source://webrick//lib/webrick/httpserver.rb#173 - def umount(dir); end - - # Unmounts +dir+ - # - # source://webrick//lib/webrick/httpserver.rb#173 - def unmount(dir); end - - # Adds +server+ as a virtual host. - # - # source://webrick//lib/webrick/httpserver.rb#193 - def virtual_host(server); end -end - -# Mount table for the path a servlet is mounted on in the directory space -# of the server. Users of WEBrick can only access this indirectly via -# WEBrick::HTTPServer#mount, WEBrick::HTTPServer#unmount and -# WEBrick::HTTPServer#search_servlet -# -# source://webrick//lib/webrick/httpserver.rb#247 -class WEBrick::HTTPServer::MountTable - # @return [MountTable] a new instance of MountTable - # - # source://webrick//lib/webrick/httpserver.rb#248 - def initialize; end - - # source://webrick//lib/webrick/httpserver.rb#253 - def [](dir); end - - # source://webrick//lib/webrick/httpserver.rb#258 - def []=(dir, val); end - - # source://webrick//lib/webrick/httpserver.rb#265 - def delete(dir); end - - # source://webrick//lib/webrick/httpserver.rb#272 - def scan(path); end - - private - - # source://webrick//lib/webrick/httpserver.rb#279 - def compile; end - - # source://webrick//lib/webrick/httpserver.rb#287 - def normalize(dir); end -end - -# AbstractServlet allows HTTP server modules to be reused across multiple -# servers and allows encapsulation of functionality. -# -# By default a servlet will respond to GET, HEAD (through an alias to GET) -# and OPTIONS requests. -# -# By default a new servlet is initialized for every request. A servlet -# instance can be reused by overriding ::get_instance in the -# AbstractServlet subclass. -# -# == A Simple Servlet -# -# class Simple < WEBrick::HTTPServlet::AbstractServlet -# def do_GET request, response -# status, content_type, body = do_stuff_with request -# -# response.status = status -# response['Content-Type'] = content_type -# response.body = body -# end -# -# def do_stuff_with request -# return 200, 'text/plain', 'you got a page' -# end -# end -# -# This servlet can be mounted on a server at a given path: -# -# server.mount '/simple', Simple -# -# == Servlet Configuration -# -# Servlets can be configured via initialize. The first argument is the -# HTTP server the servlet is being initialized for. -# -# class Configurable < Simple -# def initialize server, color, size -# super server -# @color = color -# @size = size -# end -# -# def do_stuff_with request -# content = "

Hello, World!" -# -# return 200, "text/html", content -# end -# end -# -# This servlet must be provided two arguments at mount time: -# -# server.mount '/configurable', Configurable, 'red', '2em' -# -# source://webrick//lib/webrick/httpservlet/abstract.rb#76 -class WEBrick::HTTPServlet::AbstractServlet - # Initializes a new servlet for +server+ using +options+ which are - # stored as-is in +@options+. +@logger+ is also provided. - # - # @return [AbstractServlet] a new instance of AbstractServlet - # - # source://webrick//lib/webrick/httpservlet/abstract.rb#91 - def initialize(server, *options); end - - # Raises a NotFound exception - # - # @raise [HTTPStatus::NotFound] - # - # source://webrick//lib/webrick/httpservlet/abstract.rb#115 - def do_GET(req, res); end - - # Dispatches to do_GET - # - # source://webrick//lib/webrick/httpservlet/abstract.rb#122 - def do_HEAD(req, res); end - - # Returns the allowed HTTP request methods - # - # source://webrick//lib/webrick/httpservlet/abstract.rb#129 - def do_OPTIONS(req, res); end - - # Dispatches to a +do_+ method based on +req+ if such a method is - # available. (+do_GET+ for a GET request). Raises a MethodNotAllowed - # exception if the method is not implemented. - # - # source://webrick//lib/webrick/httpservlet/abstract.rb#102 - def service(req, res); end - - private - - # Redirects to a path ending in / - # - # source://webrick//lib/webrick/httpservlet/abstract.rb#140 - def redirect_to_directory_uri(req, res); end - - class << self - # Factory for servlet instances that will handle a request from +server+ - # using +options+ from the mount point. By default a new servlet - # instance is created for every call. - # - # source://webrick//lib/webrick/httpservlet/abstract.rb#83 - def get_instance(server, *options); end - end -end - -# Servlet for handling CGI scripts -# -# Example: -# -# server.mount('/cgi/my_script', WEBrick::HTTPServlet::CGIHandler, -# '/path/to/my_script') -# -# source://webrick//lib/webrick/httpservlet/cgihandler.rb#28 -class WEBrick::HTTPServlet::CGIHandler < ::WEBrick::HTTPServlet::AbstractServlet - # Creates a new CGI script servlet for the script at +name+ - # - # @return [CGIHandler] a new instance of CGIHandler - # - # source://webrick//lib/webrick/httpservlet/cgihandler.rb#36 - def initialize(server, name); end - - # :stopdoc: - # - # @raise [HTTPStatus::InternalServerError] - # - # source://webrick//lib/webrick/httpservlet/cgihandler.rb#50 - def do_GET(req, res); end - - # :stopdoc: - # - # @raise [HTTPStatus::InternalServerError] - # - # source://webrick//lib/webrick/httpservlet/cgihandler.rb#50 - def do_POST(req, res); end -end - -# source://webrick//lib/webrick/httpservlet/cgihandler.rb#31 -WEBrick::HTTPServlet::CGIHandler::CGIRunnerArray = T.let(T.unsafe(nil), Array) - -# Servlet for serving a single file. You probably want to use the -# FileHandler servlet instead as it handles directories and fancy indexes. -# -# Example: -# -# server.mount('/my_page.txt', WEBrick::HTTPServlet::DefaultFileHandler, -# '/path/to/my_page.txt') -# -# This servlet handles If-Modified-Since and Range requests. -# -# source://webrick//lib/webrick/httpservlet/filehandler.rb#32 -class WEBrick::HTTPServlet::DefaultFileHandler < ::WEBrick::HTTPServlet::AbstractServlet - # Creates a DefaultFileHandler instance for the file at +local_path+. - # - # @return [DefaultFileHandler] a new instance of DefaultFileHandler - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#37 - def initialize(server, local_path); end - - # :stopdoc: - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#44 - def do_GET(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#118 - def make_partial_content(req, res, filename, filesize); end - - # returns a lambda for webrick/httpresponse.rb send_body_proc - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#90 - def multipart_body(body, parts, boundary, mtype, filesize); end - - # @return [Boolean] - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#64 - def not_modified?(req, res, mtime, etag); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#155 - def prepare_range(range, filesize); end -end - -# ERBHandler evaluates an ERB file and returns the result. This handler -# is automatically used if there are .rhtml files in a directory served by -# the FileHandler. -# -# ERBHandler supports GET and POST methods. -# -# The ERB file is evaluated with the local variables +servlet_request+ and -# +servlet_response+ which are a WEBrick::HTTPRequest and -# WEBrick::HTTPResponse respectively. -# -# Example .rhtml file: -# -# Request to <%= servlet_request.request_uri %> -# -# Query params <%= servlet_request.query.inspect %> -# -# source://webrick//lib/webrick/httpservlet/erbhandler.rb#36 -class WEBrick::HTTPServlet::ERBHandler < ::WEBrick::HTTPServlet::AbstractServlet - # Creates a new ERBHandler on +server+ that will evaluate and serve the - # ERB file +name+ - # - # @return [ERBHandler] a new instance of ERBHandler - # - # source://webrick//lib/webrick/httpservlet/erbhandler.rb#42 - def initialize(server, name); end - - # Handles GET requests - # - # source://webrick//lib/webrick/httpservlet/erbhandler.rb#50 - def do_GET(req, res); end - - # Handles GET requests - # - # Handles POST requests - # - # source://webrick//lib/webrick/httpservlet/erbhandler.rb#50 - def do_POST(req, res); end - - private - - # Evaluates +erb+ providing +servlet_request+ and +servlet_response+ as - # local variables. - # - # source://webrick//lib/webrick/httpservlet/erbhandler.rb#79 - def evaluate(erb, servlet_request, servlet_response); end -end - -# Serves a directory including fancy indexing and a variety of other -# options. -# -# Example: -# -# server.mount('/assets', WEBrick::HTTPServlet::FileHandler, -# '/path/to/assets') -# -# source://webrick//lib/webrick/httpservlet/filehandler.rb#175 -class WEBrick::HTTPServlet::FileHandler < ::WEBrick::HTTPServlet::AbstractServlet - # Creates a FileHandler servlet on +server+ that serves files starting - # at directory +root+ - # - # +options+ may be a Hash containing keys from - # WEBrick::Config::FileHandler or +true+ or +false+. - # - # If +options+ is true or false then +:FancyIndexing+ is enabled or - # disabled respectively. - # - # @return [FileHandler] a new instance of FileHandler - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#203 - def initialize(server, root, options = T.unsafe(nil), default = T.unsafe(nil)); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#245 - def do_GET(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#257 - def do_OPTIONS(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#251 - def do_POST(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#224 - def service(req, res); end - - # :stopdoc: - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#215 - def set_filesystem_encoding(str); end - - private - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#416 - def call_callback(callback_name, req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#369 - def check_filename(req, res, name); end - - # @raise [HTTPStatus::NotFound] - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#309 - def exec_handler(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#322 - def get_handler(req, res); end - - # @return [Boolean] - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#428 - def nondisclosure_name?(name); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#286 - def prevent_directory_traversal(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#394 - def search_file(req, res, basename); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#385 - def search_index_file(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#437 - def set_dir_list(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#335 - def set_filename(req, res); end - - # source://webrick//lib/webrick/httpservlet/filehandler.rb#376 - def shift_path_info(req, res, path_info, base = T.unsafe(nil)); end - - # @return [Boolean] - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#277 - def trailing_pathsep?(path); end - - # @return [Boolean] - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#422 - def windows_ambiguous_name?(name); end - - class << self - # Allow custom handling of requests for files with +suffix+ by class - # +handler+ - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#182 - def add_handler(suffix, handler); end - - # Remove custom handling of requests for files with +suffix+ - # - # source://webrick//lib/webrick/httpservlet/filehandler.rb#189 - def remove_handler(suffix); end - end -end - -# This module is used to manager HTTP status codes. -# -# See http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html for more -# information. -# -# source://webrick//lib/webrick/httpstatus.rb#21 -module WEBrick::HTTPStatus - private - - # Is +code+ a client error status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#170 - def client_error?(code); end - - # Is +code+ an error status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#164 - def error?(code); end - - # Is +code+ an informational status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#146 - def info?(code); end - - # Returns the description corresponding to the HTTP status +code+ - # - # WEBrick::HTTPStatus.reason_phrase 404 - # => "Not Found" - # - # source://webrick//lib/webrick/httpstatus.rb#140 - def reason_phrase(code); end - - # Is +code+ a redirection status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#158 - def redirect?(code); end - - # Is +code+ a server error status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#176 - def server_error?(code); end - - # Is +code+ a successful status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#152 - def success?(code); end - - class << self - # Returns the status class corresponding to +code+ - # - # WEBrick::HTTPStatus[302] - # => WEBrick::HTTPStatus::NotFound - # - # source://webrick//lib/webrick/httpstatus.rb#186 - def [](code); end - - # Is +code+ a client error status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#170 - def client_error?(code); end - - # Is +code+ an error status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#164 - def error?(code); end - - # Is +code+ an informational status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#146 - def info?(code); end - - # Returns the description corresponding to the HTTP status +code+ - # - # WEBrick::HTTPStatus.reason_phrase 404 - # => "Not Found" - # - # source://webrick//lib/webrick/httpstatus.rb#140 - def reason_phrase(code); end - - # Is +code+ a redirection status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#158 - def redirect?(code); end - - # Is +code+ a server error status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#176 - def server_error?(code); end - - # Is +code+ a successful status? - # - # @return [Boolean] - # - # source://webrick//lib/webrick/httpstatus.rb#152 - def success?(code); end - end -end - -# Root of the HTTP status class hierarchy -# -# source://webrick//lib/webrick/httpstatus.rb#25 -class WEBrick::HTTPStatus::Status < ::StandardError - # Returns the HTTP status code - # - # source://webrick//lib/webrick/httpstatus.rb#31 - def code; end - - # Returns the HTTP status description - # - # source://webrick//lib/webrick/httpstatus.rb#34 - def reason_phrase; end - - # Returns the HTTP status code - # - # source://webrick//lib/webrick/httpstatus.rb#31 - def to_i; end - - class << self - # source://webrick//lib/webrick/httpstatus.rb#27 - def code; end - - # source://webrick//lib/webrick/httpstatus.rb#27 - def reason_phrase; end - end -end - -# HTTPUtils provides utility methods for working with the HTTP protocol. -# -# This module is generally used internally by WEBrick -# -# source://webrick//lib/webrick/httputils.rb#25 -module WEBrick::HTTPUtils - private - - # source://webrick//lib/webrick/httputils.rb#443 - def _escape(str, regex); end - - # :stopdoc: - # - # source://webrick//lib/webrick/httputils.rb#441 - def _make_regex(str); end - - # source://webrick//lib/webrick/httputils.rb#442 - def _make_regex!(str); end - - # source://webrick//lib/webrick/httputils.rb#449 - def _unescape(str, regex); end - - # Removes quotes and escapes from +str+ - # - # source://webrick//lib/webrick/httputils.rb#223 - def dequote(str); end - - # Escapes HTTP reserved and unwise characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#467 - def escape(str); end - - # Escapes 8 bit characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#508 - def escape8bit(str); end - - # Escapes form reserved characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#481 - def escape_form(str); end - - # Escapes path +str+ - # - # source://webrick//lib/webrick/httputils.rb#497 - def escape_path(str); end - - # Loads Apache-compatible mime.types in +file+. - # - # source://webrick//lib/webrick/httputils.rb#112 - def load_mime_types(file); end - - # Returns the mime type of +filename+ from the list in +mime_tab+. If no - # mime type was found application/octet-stream is returned. - # - # source://webrick//lib/webrick/httputils.rb#134 - def mime_type(filename, mime_tab); end - - # Normalizes a request path. Raises an exception if the path cannot be - # normalized. - # - # source://webrick//lib/webrick/httputils.rb#31 - def normalize_path(path); end - - # Parses form data in +io+ with the given +boundary+ - # - # source://webrick//lib/webrick/httputils.rb#395 - def parse_form_data(io, boundary); end - - # Parses an HTTP header +raw+ into a hash of header fields with an Array - # of values. - # - # source://webrick//lib/webrick/httputils.rb#145 - def parse_header(raw); end - - # Parses the query component of a URI in +str+ - # - # source://webrick//lib/webrick/httputils.rb#371 - def parse_query(str); end - - # Parses q values in +value+ as used in Accept headers. - # - # source://webrick//lib/webrick/httputils.rb#202 - def parse_qvalues(value); end - - # Parses a Range header value +ranges_specifier+ - # - # source://webrick//lib/webrick/httputils.rb#184 - def parse_range_header(ranges_specifier); end - - # Quotes and escapes quotes in +str+ - # - # source://webrick//lib/webrick/httputils.rb#233 - def quote(str); end - - # Splits a header value +str+ according to HTTP specification. - # - # source://webrick//lib/webrick/httputils.rb#175 - def split_header_value(str); end - - # Unescapes HTTP reserved and unwise characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#474 - def unescape(str); end - - # Unescapes form reserved characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#490 - def unescape_form(str); end - - class << self - # source://webrick//lib/webrick/httputils.rb#443 - def _escape(str, regex); end - - # :stopdoc: - # - # source://webrick//lib/webrick/httputils.rb#441 - def _make_regex(str); end - - # source://webrick//lib/webrick/httputils.rb#442 - def _make_regex!(str); end - - # source://webrick//lib/webrick/httputils.rb#449 - def _unescape(str, regex); end - - # Removes quotes and escapes from +str+ - # - # source://webrick//lib/webrick/httputils.rb#223 - def dequote(str); end - - # Escapes HTTP reserved and unwise characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#467 - def escape(str); end - - # Escapes 8 bit characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#508 - def escape8bit(str); end - - # Escapes form reserved characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#481 - def escape_form(str); end - - # Escapes path +str+ - # - # source://webrick//lib/webrick/httputils.rb#497 - def escape_path(str); end - - # Loads Apache-compatible mime.types in +file+. - # - # source://webrick//lib/webrick/httputils.rb#112 - def load_mime_types(file); end - - # Returns the mime type of +filename+ from the list in +mime_tab+. If no - # mime type was found application/octet-stream is returned. - # - # source://webrick//lib/webrick/httputils.rb#134 - def mime_type(filename, mime_tab); end - - # Normalizes a request path. Raises an exception if the path cannot be - # normalized. - # - # source://webrick//lib/webrick/httputils.rb#31 - def normalize_path(path); end - - # Parses form data in +io+ with the given +boundary+ - # - # source://webrick//lib/webrick/httputils.rb#395 - def parse_form_data(io, boundary); end - - # Parses an HTTP header +raw+ into a hash of header fields with an Array - # of values. - # - # source://webrick//lib/webrick/httputils.rb#145 - def parse_header(raw); end - - # Parses the query component of a URI in +str+ - # - # source://webrick//lib/webrick/httputils.rb#371 - def parse_query(str); end - - # Parses q values in +value+ as used in Accept headers. - # - # source://webrick//lib/webrick/httputils.rb#202 - def parse_qvalues(value); end - - # Parses a Range header value +ranges_specifier+ - # - # source://webrick//lib/webrick/httputils.rb#184 - def parse_range_header(ranges_specifier); end - - # Quotes and escapes quotes in +str+ - # - # source://webrick//lib/webrick/httputils.rb#233 - def quote(str); end - - # Splits a header value +str+ according to HTTP specification. - # - # source://webrick//lib/webrick/httputils.rb#175 - def split_header_value(str); end - - # Unescapes HTTP reserved and unwise characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#474 - def unescape(str); end - - # Unescapes form reserved characters in +str+ - # - # source://webrick//lib/webrick/httputils.rb#490 - def unescape_form(str); end - end -end - -# Stores multipart form data. FormData objects are created when -# WEBrick::HTTPUtils.parse_form_data is called. -# -# source://webrick//lib/webrick/httputils.rb#242 -class WEBrick::HTTPUtils::FormData < ::String - # Creates a new FormData object. - # - # +args+ is an Array of form data entries. One FormData will be created - # for each entry. - # - # This is called by WEBrick::HTTPUtils.parse_form_data for you - # - # @return [FormData] a new instance of FormData - # - # source://webrick//lib/webrick/httputils.rb#267 - def initialize(*args); end - - # Adds +str+ to this FormData which may be the body, a header or a - # header entry. - # - # This is called by WEBrick::HTTPUtils.parse_form_data for you - # - # source://webrick//lib/webrick/httputils.rb#300 - def <<(str); end - - # Retrieves the header at the first entry in +key+ - # - # source://webrick//lib/webrick/httputils.rb#286 - def [](*key); end - - # Adds +data+ at the end of the chain of entries - # - # This is called by WEBrick::HTTPUtils.parse_form_data for you. - # - # source://webrick//lib/webrick/httputils.rb#320 - def append_data(data); end - - # Yields each entry in this FormData - # - # source://webrick//lib/webrick/httputils.rb#335 - def each_data; end - - # The filename of the form data part - # - # source://webrick//lib/webrick/httputils.rb#254 - def filename; end - - # The filename of the form data part - # - # source://webrick//lib/webrick/httputils.rb#254 - def filename=(_arg0); end - - # Returns all the FormData as an Array - # - # source://webrick//lib/webrick/httputils.rb#347 - def list; end - - # The name of the form data part - # - # source://webrick//lib/webrick/httputils.rb#249 - def name; end - - # The name of the form data part - # - # source://webrick//lib/webrick/httputils.rb#249 - def name=(_arg0); end - - # source://webrick//lib/webrick/httputils.rb#256 - def next_data=(_arg0); end - - # Returns all the FormData as an Array - # - # A FormData will behave like an Array - # - # source://webrick//lib/webrick/httputils.rb#347 - def to_ary; end - - # This FormData's body - # - # source://webrick//lib/webrick/httputils.rb#363 - def to_s; end - - protected - - # source://webrick//lib/webrick/httputils.rb#256 - def next_data; end -end - -# source://webrick//lib/webrick/utils.rb#17 -module WEBrick::Utils - private - - # Creates TCP server sockets bound to +address+:+port+ and returns them. - # - # It will create IPV4 and IPV6 sockets on all interfaces. - # - # source://webrick//lib/webrick/utils.rb#56 - def create_listeners(address, port); end - - # The server hostname - # - # source://webrick//lib/webrick/utils.rb#47 - def getservername; end - - # Generates a random string of length +len+ - # - # source://webrick//lib/webrick/utils.rb#79 - def random_string(len); end - - # Sets the close on exec flag for +io+ - # - # source://webrick//lib/webrick/utils.rb#27 - def set_close_on_exec(io); end - - # Sets IO operations on +io+ to be non-blocking - # - # source://webrick//lib/webrick/utils.rb#20 - def set_non_blocking(io); end - - # Changes the process's uid and gid to the ones of +user+ - # - # source://webrick//lib/webrick/utils.rb#34 - def su(user); end - - # Executes the passed block and raises +exception+ if execution takes more - # than +seconds+. - # - # If +seconds+ is zero or nil, simply executes the block - # - # source://webrick//lib/webrick/utils.rb#253 - def timeout(seconds, exception = T.unsafe(nil)); end - - class << self - # Creates TCP server sockets bound to +address+:+port+ and returns them. - # - # It will create IPV4 and IPV6 sockets on all interfaces. - # - # source://webrick//lib/webrick/utils.rb#56 - def create_listeners(address, port); end - - # The server hostname - # - # source://webrick//lib/webrick/utils.rb#47 - def getservername; end - - # Generates a random string of length +len+ - # - # source://webrick//lib/webrick/utils.rb#79 - def random_string(len); end - - # Sets the close on exec flag for +io+ - # - # source://webrick//lib/webrick/utils.rb#27 - def set_close_on_exec(io); end - - # Sets IO operations on +io+ to be non-blocking - # - # source://webrick//lib/webrick/utils.rb#20 - def set_non_blocking(io); end - - # Changes the process's uid and gid to the ones of +user+ - # - # source://webrick//lib/webrick/utils.rb#34 - def su(user); end - - # Executes the passed block and raises +exception+ if execution takes more - # than +seconds+. - # - # If +seconds+ is zero or nil, simply executes the block - # - # source://webrick//lib/webrick/utils.rb#253 - def timeout(seconds, exception = T.unsafe(nil)); end - end -end - -# Class used to manage timeout handlers across multiple threads. -# -# Timeout handlers should be managed by using the class methods which are -# synchronized. -# -# id = TimeoutHandler.register(10, Timeout::Error) -# begin -# sleep 20 -# puts 'foo' -# ensure -# TimeoutHandler.cancel(id) -# end -# -# will raise Timeout::Error -# -# id = TimeoutHandler.register(10, Timeout::Error) -# begin -# sleep 5 -# puts 'foo' -# ensure -# TimeoutHandler.cancel(id) -# end -# -# will print 'foo' -# -# source://webrick//lib/webrick/utils.rb#118 -class WEBrick::Utils::TimeoutHandler - include ::Singleton - extend ::Singleton::SingletonClassMethods - - # Creates a new TimeoutHandler. You should use ::register and ::cancel - # instead of creating the timeout handler directly. - # - # @return [TimeoutHandler] a new instance of TimeoutHandler - # - # source://webrick//lib/webrick/utils.rb#148 - def initialize; end - - # Cancels the timeout handler +id+ - # - # source://webrick//lib/webrick/utils.rb#226 - def cancel(thread, id); end - - # Interrupts the timeout handler +id+ and raises +exception+ - # - # source://webrick//lib/webrick/utils.rb#203 - def interrupt(thread, id, exception); end - - # Registers a new timeout handler - # - # +time+:: Timeout in seconds - # +exception+:: Exception to raise when timeout elapsed - # - # source://webrick//lib/webrick/utils.rb#214 - def register(thread, time, exception); end - - # source://webrick//lib/webrick/utils.rb#240 - def terminate; end - - private - - # source://webrick//lib/webrick/utils.rb#158 - def watch; end - - # source://webrick//lib/webrick/utils.rb#193 - def watcher; end - - class << self - # Cancels the timeout handler +id+ - # - # source://webrick//lib/webrick/utils.rb#137 - def cancel(id); end - - # Registers a new timeout handler - # - # +time+:: Timeout in seconds - # +exception+:: Exception to raise when timeout elapsed - # - # source://webrick//lib/webrick/utils.rb#130 - def register(seconds, exception); end - - # source://webrick//lib/webrick/utils.rb#141 - def terminate; end - end -end diff --git a/sorbet/rbi/gems/yard-sorbet@0.8.0.rbi b/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi similarity index 92% rename from sorbet/rbi/gems/yard-sorbet@0.8.0.rbi rename to sorbet/rbi/gems/yard-sorbet@0.8.1.rbi index cb323f93..fb10cc0d 100644 --- a/sorbet/rbi/gems/yard-sorbet@0.8.0.rbi +++ b/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi @@ -231,7 +231,7 @@ class YARDSorbet::Handlers::StructPropHandler < ::YARD::Handlers::Ruby::Base def make_prop(name); end # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#60 - sig { returns(T::Array[T.untyped]) } + sig { returns(T::Array[::YARD::Parser::Ruby::AstNode]) } def params; end # Register the field explicitly as an attribute. @@ -322,67 +322,54 @@ module YARDSorbet::SigToYARD class << self # @see https://yardoc.org/types.html # - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#22 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#23 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert(node); end private - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#55 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#61 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::String) } def build_generic_type(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#64 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#70 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_aref(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#76 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#82 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) } def convert_array(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#84 - sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) } - def convert_call(node); end - - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#89 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#90 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) } def convert_collection(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#96 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#97 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) } def convert_hash(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#104 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#105 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_list(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#28 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#31 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_node(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#37 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#43 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) } def convert_node_type(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#109 - sig { params(node_source: ::String).returns([::String]) } - def convert_ref(node_source); end - - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#114 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#110 sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) } def convert_t_method(node); end - # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#125 + # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#121 sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) } def convert_unknown(node); end end end -# Map of common types to YARD conventions (in order to reduce allocations) -# -# source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#10 -YARDSorbet::SigToYARD::REF_TYPES = T.let(T.unsafe(nil), Hash) - # Used to store the details of a `T::Struct` `prop` definition # # source://yard-sorbet//lib/yard-sorbet/t_struct_prop.rb#6 @@ -394,7 +381,7 @@ class YARDSorbet::TStructProp < ::T::Struct const :types, T::Array[::String] class << self - # source://sorbet-runtime/0.5.10741/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.10875/lib/types/struct.rb#13 def inherited(s); end end end diff --git a/sorbet/rbi/gems/yard@0.9.28.rbi b/sorbet/rbi/gems/yard@0.9.34.rbi similarity index 95% rename from sorbet/rbi/gems/yard@0.9.28.rbi rename to sorbet/rbi/gems/yard@0.9.34.rbi index ac8624f8..39510918 100644 --- a/sorbet/rbi/gems/yard@0.9.28.rbi +++ b/sorbet/rbi/gems/yard@0.9.34.rbi @@ -503,7 +503,7 @@ end # A subclass of Hash where all keys are converted into Symbols, and # optionally, all String values are converted into Symbols. # -# source://yard//lib/yard/core_ext/symbol_hash.rb#8 +# source://yard//lib/yard/core_ext/symbol_hash.rb#4 class SymbolHash < ::Hash # Creates a new SymbolHash object # @@ -590,28 +590,6 @@ class SymbolHash < ::Hash end end -# @private -# -# source://yard//lib/yard/server/webrick_adapter.rb#42 -class WEBrick::HTTPRequest - # Returns the value of attribute version_supplied. - # - # source://yard//lib/yard/server/webrick_adapter.rb#43 - def version_supplied; end - - # Sets the attribute version_supplied - # - # @param value the value to set the attribute version_supplied to. - # - # source://yard//lib/yard/server/webrick_adapter.rb#43 - def version_supplied=(_arg0); end - - # @return [Boolean] - # - # source://yard//lib/yard/server/webrick_adapter.rb#44 - def xhr?; end -end - # Gem::YARDoc provides methods to generate YARDoc and yri data for installed gems # upon gem installation. # @@ -830,7 +808,7 @@ end # # @since 0.6.2 # -# source://yard//lib/yard/cli/config.rb#7 +# source://yard//lib/yard/cli/config.rb#6 class YARD::CLI::Config < ::YARD::CLI::Command # @return [Config] a new instance of Config # @since 0.6.2 @@ -1151,7 +1129,7 @@ end # @see Graph#run # @since 0.6.0 # -# source://yard//lib/yard/cli/graph.rb#27 +# source://yard//lib/yard/cli/graph.rb#24 class YARD::CLI::Graph < ::YARD::CLI::YardoptsCommand # Creates a new instance of the command-line utility # @@ -1211,7 +1189,7 @@ end # Options to pass to the {Graph} CLI. # -# source://yard//lib/yard/cli/graph.rb#6 +# source://yard//lib/yard/cli/graph.rb#5 class YARD::CLI::GraphOptions < ::YARD::Templates::TemplateOptions # @return [String] any contents to pass to the digraph # @@ -1351,7 +1329,7 @@ end # # @since 0.6.0 # -# source://yard//lib/yard/cli/server.rb#8 +# source://yard//lib/yard/cli/server.rb#7 class YARD::CLI::Server < ::YARD::CLI::Command # Creates a new instance of the Server command line utility # @@ -1654,7 +1632,7 @@ YARD::CLI::Stats::STATS_ORDER = T.let(T.unsafe(nil), Array) # A tool to view documentation in the console like `ri` # -# source://yard//lib/yard/cli/yri.rb#9 +# source://yard//lib/yard/cli/yri.rb#7 class YARD::CLI::YRI < ::YARD::CLI::Command # @return [YRI] a new instance of YRI # @@ -1784,7 +1762,7 @@ YARD::CLI::YRI::DEFAULT_SEARCH_PATHS = T.let(T.unsafe(nil), Array) # source://yard//lib/yard/cli/yri.rb#15 YARD::CLI::YRI::SEARCH_PATHS_FILE = T.let(T.unsafe(nil), String) -# source://yard//lib/yard/cli/yardoc.rb#147 +# source://yard//lib/yard/cli/yardoc.rb#145 class YARD::CLI::Yardoc < ::YARD::CLI::YardoptsCommand # Creates a new instance of the commandline utility # @@ -2121,7 +2099,7 @@ class YARD::CLI::Yardoc < ::YARD::CLI::YardoptsCommand # Generates output for objects # - # @param checksums [Hash, nil] if supplied, a list of checkums for files. + # @param checksums [Hash, nil] if supplied, a list of checksums for files. # @return [void] # @since 0.5.1 # @@ -2157,7 +2135,7 @@ end # Default options used in +yard doc+ command. # -# source://yard//lib/yard/cli/yardoc.rb#10 +# source://yard//lib/yard/cli/yardoc.rb#8 class YARD::CLI::YardocOptions < ::YARD::Templates::TemplateOptions # @return [CodeObjects::ExtraFileObject] the file object being rendered. # The +object+ key is not used so that a file may be rendered in the context @@ -2285,7 +2263,7 @@ end # @abstract # @since 0.8.3 # -# source://yard//lib/yard/cli/yardopts_command.rb#11 +# source://yard//lib/yard/cli/yardopts_command.rb#10 class YARD::CLI::YardoptsCommand < ::YARD::CLI::Command # Creates a new command that reads .yardopts # @@ -2542,7 +2520,7 @@ class YARD::CodeObjects::Base # @see Docstring#add_tag # @since 0.8.4 # - # source://yard//lib/yard/code_objects/base.rb#557 + # source://yard//lib/yard/code_objects/base.rb#560 def add_tag(*tags); end # The non-localized documentation string associated with the object @@ -2651,7 +2629,7 @@ class YARD::CodeObjects::Base # @return [String] the rendered template # @see Templates::Engine#render # - # source://yard//lib/yard/code_objects/base.rb#501 + # source://yard//lib/yard/code_objects/base.rb#504 def format(options = T.unsafe(nil)); end # @return [String] the group this object is associated with @@ -2671,7 +2649,7 @@ class YARD::CodeObjects::Base # @return [Boolean] # @see Docstring#has_tag? # - # source://yard//lib/yard/code_objects/base.rb#552 + # source://yard//lib/yard/code_objects/base.rb#555 def has_tag?(name); end # @return [Integer] the object's hash value (for equality checking) @@ -2683,7 +2661,7 @@ class YARD::CodeObjects::Base # # @return [String] a string describing the object # - # source://yard//lib/yard/code_objects/base.rb#509 + # source://yard//lib/yard/code_objects/base.rb#512 def inspect; end # Returns the line the object was first parsed at (or nil) @@ -2725,7 +2703,7 @@ class YARD::CodeObjects::Base # for {Registry.root}). If obj is nil, the object is unregistered # from the Registry. # - # source://yard//lib/yard/code_objects/base.rb#518 + # source://yard//lib/yard/code_objects/base.rb#521 def namespace=(obj); end # The namespace the object is defined in. If the object is in the @@ -2742,7 +2720,7 @@ class YARD::CodeObjects::Base # for {Registry.root}). If obj is nil, the object is unregistered # from the Registry. # - # source://yard//lib/yard/code_objects/base.rb#518 + # source://yard//lib/yard/code_objects/base.rb#521 def parent=(obj); end # Represents the unique path of the object. The default implementation @@ -2755,19 +2733,19 @@ class YARD::CodeObjects::Base # @return [String] the unique path of the object # @see #sep # - # source://yard//lib/yard/code_objects/base.rb#449 + # source://yard//lib/yard/code_objects/base.rb#452 def path; end # @param other [Base, String] another code object (or object path) # @return [String] the shortest relative path from this object to +other+ # @since 0.5.3 # - # source://yard//lib/yard/code_objects/base.rb#471 + # source://yard//lib/yard/code_objects/base.rb#474 def relative_path(other); end # @return [Boolean] whether or not this object is a RootObject # - # source://yard//lib/yard/code_objects/base.rb#563 + # source://yard//lib/yard/code_objects/base.rb#566 def root?; end # Override this method with a custom component separator. For instance, @@ -2778,7 +2756,7 @@ class YARD::CodeObjects::Base # @return [String] the component that separates the namespace path # and the name (default is {NSEP}) # - # source://yard//lib/yard/code_objects/base.rb#572 + # source://yard//lib/yard/code_objects/base.rb#575 def sep; end # The one line signature representing an object. For a method, this will @@ -2834,14 +2812,14 @@ class YARD::CodeObjects::Base # # @see Docstring#tag # - # source://yard//lib/yard/code_objects/base.rb#544 + # source://yard//lib/yard/code_objects/base.rb#547 def tag(name); end # Gets a list of tags from the {#docstring} # # @see Docstring#tags # - # source://yard//lib/yard/code_objects/base.rb#548 + # source://yard//lib/yard/code_objects/base.rb#551 def tags(name = T.unsafe(nil)); end # @note Override this method if your object has a special title that does @@ -2850,7 +2828,7 @@ class YARD::CodeObjects::Base # @return [String] the display title for an object # @see 0.8.4 # - # source://yard//lib/yard/code_objects/base.rb#464 + # source://yard//lib/yard/code_objects/base.rb#467 def title; end # @return [nil] this object does not turn into an array @@ -2868,7 +2846,7 @@ class YARD::CodeObjects::Base # @return [String] the unique path of the object # @see #sep # - # source://yard//lib/yard/code_objects/base.rb#449 + # source://yard//lib/yard/code_objects/base.rb#452 def to_s; end # Default type is the lowercase class name without the "Object" suffix. @@ -2899,7 +2877,7 @@ class YARD::CodeObjects::Base # @see #copy_to # @since 0.8.0 # - # source://yard//lib/yard/code_objects/base.rb#583 + # source://yard//lib/yard/code_objects/base.rb#586 def copyable_attributes; end private @@ -2909,10 +2887,10 @@ class YARD::CodeObjects::Base # @param source [String] the source code to format # @return [String] formatted source # - # source://yard//lib/yard/code_objects/base.rb#595 + # source://yard//lib/yard/code_objects/base.rb#598 def format_source(source); end - # source://yard//lib/yard/code_objects/base.rb#602 + # source://yard//lib/yard/code_objects/base.rb#605 def translate_docstring(locale); end class << self @@ -2959,7 +2937,7 @@ YARD::CodeObjects::CSEPQ = T.let(T.unsafe(nil), String) # A ClassObject represents a Ruby class in source code. It is a {ModuleObject} # with extra inheritance semantics through the superclass. # -# source://yard//lib/yard/code_objects/class_object.rb#9 +# source://yard//lib/yard/code_objects/class_object.rb#7 class YARD::CodeObjects::ClassObject < ::YARD::CodeObjects::NamespaceObject # Creates a new class object in +namespace+ with +name+ # @@ -3040,7 +3018,7 @@ end # Represents a class variable inside a namespace. The path is expressed # in the form "A::B::@@classvariable" # -# source://yard//lib/yard/code_objects/class_variable_object.rb#8 +# source://yard//lib/yard/code_objects/class_variable_object.rb#7 class YARD::CodeObjects::ClassVariableObject < ::YARD::CodeObjects::Base # @return [String] the class variable's value # @@ -3056,7 +3034,7 @@ end # A list of code objects. This array acts like a set (no unique items) # but also disallows any {Proxy} objects from being added. # -# source://yard//lib/yard/code_objects/base.rb#10 +# source://yard//lib/yard/code_objects/base.rb#6 class YARD::CodeObjects::CodeObjectList < ::Array # Creates a new object list associated with a namespace # @@ -3086,7 +3064,7 @@ end # A +ConstantObject+ represents a Ruby constant (not a module or class). # To access the constant's (source code) value, use {#value}. # -# source://yard//lib/yard/code_objects/constant_object.rb#9 +# source://yard//lib/yard/code_objects/constant_object.rb#7 class YARD::CodeObjects::ConstantObject < ::YARD::CodeObjects::Base # The source code representing the constant's value # @@ -3453,7 +3431,7 @@ YARD::CodeObjects::MacroObject::MACRO_MATCH = T.let(T.unsafe(nil), Regexp) # Represents a Ruby method in source # -# source://yard//lib/yard/code_objects/method_object.rb#10 +# source://yard//lib/yard/code_objects/method_object.rb#7 class YARD::CodeObjects::MethodObject < ::YARD::CodeObjects::Base # Creates a new method object in +namespace+ with +name+ and an instance # or class +scope+ @@ -3626,7 +3604,7 @@ end # Represents a Ruby module. # -# source://yard//lib/yard/code_objects/module_object.rb#11 +# source://yard//lib/yard/code_objects/module_object.rb#6 class YARD::CodeObjects::ModuleObject < ::YARD::CodeObjects::NamespaceObject # Returns the inheritance tree of mixins. # @@ -3791,7 +3769,7 @@ end # The two main Ruby objects that can act as namespaces are modules # ({ModuleObject}) and classes ({ClassObject}). # -# source://yard//lib/yard/code_objects/namespace_object.rb#11 +# source://yard//lib/yard/code_objects/namespace_object.rb#9 class YARD::CodeObjects::NamespaceObject < ::YARD::CodeObjects::Base # Creates a new namespace object inside +namespace+ with +name+. # @@ -4763,7 +4741,7 @@ YARD::Docstring::META_MATCH = T.let(T.unsafe(nil), Regexp) # # == Subclassing Notes # -# The DocstringParser can be subclassed and subtituted during parsing by +# The DocstringParser can be subclassed and substituted during parsing by # setting the {Docstring.default_parser} attribute with the name of the # subclass. This allows developers to change the way docstrings are # parsed, allowing for completely different docstring syntaxes. @@ -5937,7 +5915,7 @@ class YARD::Handlers::HandlerAborted < ::RuntimeError; end # an operation on an object's namespace but the namespace could # not be resolved. # -# source://yard//lib/yard/handlers/base.rb#15 +# source://yard//lib/yard/handlers/base.rb#13 class YARD::Handlers::NamespaceMissingError < ::YARD::Parser::UndocumentableError # @return [NamespaceMissingError] a new instance of NamespaceMissingError # @@ -6525,7 +6503,7 @@ class YARD::Handlers::Ruby::Legacy::AttributeHandler < ::YARD::Handlers::Ruby::L # # @abstract See {Handlers::Base} for subclassing information. # -# source://yard//lib/yard/handlers/ruby/legacy/base.rb#10 +# source://yard//lib/yard/handlers/ruby/legacy/base.rb#9 class YARD::Handlers::Ruby::Legacy::Base < ::YARD::Handlers::Base include ::YARD::Parser::Ruby::Legacy::RubyToken @@ -6843,7 +6821,7 @@ class YARD::Handlers::Ruby::MixinHandler < ::YARD::Handlers::Ruby::Base # source://yard//lib/yard/handlers/ruby/mixin_handler.rb#25 def process_mixin(mixin); end - # source://yard//lib/yard/handlers/ruby/mixin_handler.rb#43 + # source://yard//lib/yard/handlers/ruby/mixin_handler.rb#50 def recipient(mixin); end end @@ -7068,7 +7046,7 @@ class YARD::I18n::Locale def name; end # @param message [String] the translation target message. - # @return [String] translated message. If tarnslation isn't + # @return [String] translated message. If translation isn't # registered, the +message+ is returned. # @since 0.8.2 # @@ -7097,7 +7075,7 @@ end # # source://yard//lib/yard/i18n/message.rb#10 class YARD::I18n::Message - # Creates a trasnlate target message for message ID +id+. + # Creates a translate target message for message ID +id+. # # @param id [String] the message ID of the translate target message. # @return [Message] a new instance of Message @@ -7138,7 +7116,7 @@ class YARD::I18n::Message # source://yard//lib/yard/i18n/message.rb#19 def comments; end - # @return [String] the message ID of the trnslation target message. + # @return [String] the message ID of the translation target message. # @since 0.8.1 # # source://yard//lib/yard/i18n/message.rb#12 @@ -7196,7 +7174,7 @@ class YARD::I18n::Messages # source://yard//lib/yard/i18n/messages.rb#20 def each(&block); end - # Registers a {Message}, the mssage ID of which is +id+. If + # Registers a {Message}, the message ID of which is +id+. If # corresponding +Message+ is already registered, the previously # registered object is returned. # @@ -7298,7 +7276,7 @@ class YARD::I18n::PotGenerator # # Locations of the +Message+ are used to generate the reference # line that is started with "#: ". +relative_base_path+ passed - # when the generater is created is prepended to each path in location. + # when the generator is created is prepended to each path in location. # # Comments of the +Message+ are used to generate the # translator-comment line that is started with "# ". @@ -7481,7 +7459,7 @@ end # Handles console logging for info, warnings and errors. # Uses the stdlib Logger class in Ruby for all the backend logic. # -# source://yard//lib/yard/logging.rb#12 +# source://yard//lib/yard/logging.rb#9 class YARD::Logger < ::Logger # Creates a new logger # @@ -7657,7 +7635,7 @@ class YARD::Logger < ::Logger # source://yard//lib/yard/logging.rb#201 def format_log(sev, _time, _prog, msg); end - # source://logger/1.5.0/logger.rb#485 + # source://logger/1.5.3/logger.rb#682 def print_no_newline(msg); end class << self @@ -7767,7 +7745,7 @@ class YARD::Options # # @example Setting an option with Hash syntax # options[:format] = :html # equivalent to: options.format = :html - # @param key [Symbol, String] the optin to set + # @param key [Symbol, String] the option to set # @param value [Object] the value to set for the option # @return [Object] the value being set # @@ -10126,490 +10104,490 @@ class YARD::Parser::Ruby::RipperParser < ::Ripper # source://yard//lib/yard/parser/ruby/ruby_parser.rb#29 def frozen_string_line; end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_BEGIN(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_CHAR(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_END(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on___end__(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_alias(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_alias_error(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_arg_ambiguous(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_arg_paren(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_args_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_args_add_block(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_args_add_star(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_args_forward(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#149 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155 def on_args_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_aryptn(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_assign(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_assign_error(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_assoc_splat(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_backref(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_backtick(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_begin(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_binary(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_block_var(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_blockarg(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_brace_block(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_break(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_call(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_case(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_class(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_class_name_error(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_comma(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_command(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_command_call(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_const(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_const_path_field(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_const_ref(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_cvar(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_def(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_defined(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_defs(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_do_block(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_dot2(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_dot3(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_else(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_elsif(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_embexpr_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_embexpr_end(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_embvar(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_ensure(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_excessed_comma(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_fcall(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_field(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_float(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_fndptn(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_for(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_gvar(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_heredoc_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_heredoc_dedent(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_heredoc_end(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_hshptn(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_ident(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_if(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#443 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449 def on_if_mod(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_ifop(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#216 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#222 def on_ignored_nl(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_ignored_sp(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_imaginary(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_in(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_int(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_ivar(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#203 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#209 def on_kw(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_kwrest_param(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_label_end(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_lbrace(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_lparen(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_magic_comment(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_massign(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_method_add_arg(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_method_add_block(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_mlhs_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_mlhs_add_post(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_mlhs_add_star(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#149 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155 def on_mlhs_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_mlhs_paren(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_module(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_mrhs_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_mrhs_add_star(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#149 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155 def on_mrhs_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_mrhs_new_from_args(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_next(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#216 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#222 def on_nl(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_nokw_param(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#203 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#209 def on_op(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_opassign(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_operator_ambiguous(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_param_error(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_paren(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_period(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#468 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474 def on_qsymbols_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_qsymbols_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#456 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462 def on_qsymbols_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#468 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474 def on_qwords_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_qwords_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#456 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462 def on_qwords_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_rational(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_rbrace(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_redo(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_regexp_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_regexp_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_regexp_end(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_regexp_literal(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#149 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155 def on_regexp_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_rescue_mod(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_rest_param(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_retry(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_return(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_return0(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_rparen(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_sclass(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_semicolon(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_stmts_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#149 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155 def on_stmts_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_string_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_string_concat(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_string_dvar(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_string_embexpr(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_super(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_symbeg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_symbol(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_symbol_literal(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#468 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474 def on_symbols_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_symbols_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#456 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462 def on_symbols_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_tlambda(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_tlambeg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_top_const_field(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_tstring_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_tstring_content(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_tstring_end(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_undef(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_unless(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#443 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449 def on_unless_mod(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_until(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#443 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449 def on_until_mod(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_var_alias(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_var_field(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_var_ref(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#171 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177 def on_vcall(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_when(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_while(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#443 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449 def on_while_mod(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_word_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#149 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155 def on_word_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#468 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474 def on_words_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#193 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199 def on_words_beg(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#456 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462 def on_words_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#182 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188 def on_words_sep(tok); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#156 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162 def on_xstring_add(list, item); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_xstring_literal(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#149 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155 def on_xstring_new(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_yield(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_yield0(*args); end - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#164 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170 def on_zsuper(*args); end # @since 0.5.6 @@ -10636,195 +10614,195 @@ class YARD::Parser::Ruby::RipperParser < ::Ripper # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#661 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#667 def add_comment(line, node = T.unsafe(nil), before_node = T.unsafe(nil), into = T.unsafe(nil)); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#265 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#271 def add_token(token, data); end # @return [Boolean] # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#605 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#611 def comment_starts_line?(charno); end # @raise [ParserSyntaxError] # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#600 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#606 def compile_error(msg); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#687 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#693 def freeze_tree(node = T.unsafe(nil)); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#614 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#620 def insert_comments; end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#371 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#377 def on_aref(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#379 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#385 def on_aref_field(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#385 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#391 def on_array(other); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#346 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#352 def on_assoc_new(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#358 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#364 def on_assoclist_from_args(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#354 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#360 def on_bare_assoc_hash(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#341 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#347 def on_body_stmt(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#341 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#347 def on_bodystmt(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#536 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#542 def on_comment(comment); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#435 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#441 def on_const_path_ref(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#413 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#419 def on_dyna_symbol(sym); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#586 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#592 def on_embdoc(text); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#580 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#586 def on_embdoc_beg(text); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#591 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#597 def on_embdoc_end(text); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#350 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#356 def on_hash(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#528 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#534 def on_label(data); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#491 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#497 def on_lambda(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#403 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#409 def on_lbracket(tok); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#509 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#515 def on_params(*args); end # @raise [ParserSyntaxError] # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#600 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#606 def on_parse_error(msg); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#337 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#343 def on_program(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#408 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#414 def on_rbracket(tok); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#500 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#506 def on_rescue(exc, *args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#226 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#232 def on_sp(tok); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#495 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#501 def on_string_content(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#478 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#484 def on_string_literal(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#423 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#429 def on_top_const_ref(*args); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#362 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#368 def on_unary(op, val); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#505 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#511 def on_void_stmt; end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#231 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#237 def visit_event(node); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#245 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#251 def visit_event_arr(node); end # @since 0.5.6 # - # source://yard//lib/yard/parser/ruby/ruby_parser.rb#253 + # source://yard//lib/yard/parser/ruby/ruby_parser.rb#259 def visit_ns_token(token, data, ast_token = T.unsafe(nil)); end end @@ -10833,6 +10811,11 @@ end # source://yard//lib/yard/parser/ruby/ruby_parser.rb#133 YARD::Parser::Ruby::RipperParser::AST_TOKENS = T.let(T.unsafe(nil), Array) +# @since 0.5.6 +# +# source://yard//lib/yard/parser/ruby/ruby_parser.rb#136 +YARD::Parser::Ruby::RipperParser::COMMENT_SKIP_NODE_TYPES = T.let(T.unsafe(nil), Array) + # @since 0.5.6 # # source://yard//lib/yard/parser/ruby/ruby_parser.rb#78 @@ -11377,7 +11360,7 @@ module YARD::Rake; end # The rake task to run {CLI::Yardoc} and generate documentation. # -# source://yard//lib/yard/rake/yardoc_task.rb#10 +# source://yard//lib/yard/rake/yardoc_task.rb#8 class YARD::Rake::YardocTask < ::Rake::TaskLib # Creates a new task with name +name+. # @@ -11938,7 +11921,7 @@ class YARD::RegistryResolver # # @since 0.9.1 # - # source://yard//lib/yard/registry_resolver.rb#180 + # source://yard//lib/yard/registry_resolver.rb#181 def collect_namespaces(object); end # Performs a lexical lookup from a namespace for a path and a type hint. @@ -11959,20 +11942,20 @@ class YARD::RegistryResolver # occurrences of separator tokens # @since 0.9.1 # - # source://yard//lib/yard/registry_resolver.rb#205 + # source://yard//lib/yard/registry_resolver.rb#206 def split_on_separators_match; end # @return [Regexp] the regexp match of the default separator # @since 0.9.1 # - # source://yard//lib/yard/registry_resolver.rb#193 + # source://yard//lib/yard/registry_resolver.rb#194 def starts_with_default_separator_match; end # @return [Regexp] the regexp that matches strings starting with # a separator # @since 0.9.1 # - # source://yard//lib/yard/registry_resolver.rb#199 + # source://yard//lib/yard/registry_resolver.rb#200 def starts_with_separator_match; end # return [Boolean] if the obj's type matches the provided type. @@ -12315,7 +12298,7 @@ end # Implements a serializer that reads from and writes to the filesystem. # -# source://yard//lib/yard/serializers/file_system_serializer.rb#7 +# source://yard//lib/yard/serializers/file_system_serializer.rb#5 class YARD::Serializers::FileSystemSerializer < ::YARD::Serializers::Base # Creates a new FileSystemSerializer with options # @@ -12403,7 +12386,7 @@ end # serializer = ProcessSerializer.new('less') # serializer.serialize(object, "data!") # -# source://yard//lib/yard/serializers/process_serializer.rb#12 +# source://yard//lib/yard/serializers/process_serializer.rb#9 class YARD::Serializers::ProcessSerializer < ::YARD::Serializers::Base # Creates a new ProcessSerializer for the shell command +cmd+ # @@ -12422,7 +12405,7 @@ end # A serializer that writes data to standard output. # -# source://yard//lib/yard/serializers/stdout_serializer.rb#9 +# source://yard//lib/yard/serializers/stdout_serializer.rb#5 class YARD::Serializers::StdoutSerializer < ::YARD::Serializers::Base # Creates a serializer to print text to stdout # @@ -12679,6 +12662,16 @@ class YARD::Server::Adapter end end +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#16 +YARD::Server::CR = T.let(T.unsafe(nil), String) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#18 +YARD::Server::CRLF = T.let(T.unsafe(nil), String) + # Commands implement specific kinds of server responses which are routed # to by the {Router} class. To implement a custom command, subclass {Commands::Base}. # @@ -12840,7 +12833,7 @@ class YARD::Server::Commands::Base # def run # self.body = 'ERROR! The System is down!' # self.status = 500 - # self.headers['Conten-Type'] = 'text/plain' + # self.headers['Content-Type'] = 'text/plain' # end # end # @raise [NotImplementedError] @@ -13286,7 +13279,7 @@ end # # source://yard//lib/yard/server/commands/root_request_command.rb#6 class YARD::Server::Commands::RootRequestCommand < ::YARD::Server::Commands::Base - include ::WEBrick::HTTPUtils + include ::YARD::Server::HTTPUtils include ::YARD::Server::Commands::StaticFileHelpers # @since 0.6.0 @@ -13333,29 +13326,29 @@ class YARD::Server::Commands::SearchCommand < ::YARD::Server::Commands::LibraryC # @since 0.6.0 # - # source://yard//lib/yard/server/commands/search_command.rb#27 + # source://yard//lib/yard/server/commands/search_command.rb#26 def visible_results; end private # @since 0.6.0 # - # source://yard//lib/yard/server/commands/search_command.rb#59 + # source://yard//lib/yard/server/commands/search_command.rb#58 def search_for_object; end # @since 0.6.0 # - # source://yard//lib/yard/server/commands/search_command.rb#48 + # source://yard//lib/yard/server/commands/search_command.rb#47 def serve_normal; end # @since 0.6.0 # - # source://yard//lib/yard/server/commands/search_command.rb#38 + # source://yard//lib/yard/server/commands/search_command.rb#37 def serve_xhr; end # @since 0.6.0 # - # source://yard//lib/yard/server/commands/search_command.rb#33 + # source://yard//lib/yard/server/commands/search_command.rb#32 def url_for(object); end end @@ -13365,7 +13358,7 @@ end # # source://yard//lib/yard/server/commands/static_file_command.rb#6 class YARD::Server::Commands::StaticFileCommand < ::YARD::Server::Commands::LibraryCommand - include ::WEBrick::HTTPUtils + include ::YARD::Server::HTTPUtils include ::YARD::Server::Commands::StaticFileHelpers # @since 0.6.0 @@ -13389,9 +13382,9 @@ YARD::Server::Commands::StaticFileCommand::STATIC_PATHS = T.let(T.unsafe(nil), A # # @since 0.6.0 # -# source://yard//lib/yard/server/commands/static_file_helpers.rb#9 +# source://yard//lib/yard/server/commands/static_file_helpers.rb#8 module YARD::Server::Commands::StaticFileHelpers - include ::WEBrick::HTTPUtils + include ::YARD::Server::HTTPUtils # Serves an empty favicon. # @@ -13400,7 +13393,7 @@ module YARD::Server::Commands::StaticFileHelpers # @return [Boolean] # @since 0.6.0 # - # source://yard//lib/yard/server/commands/static_file_helpers.rb#15 + # source://yard//lib/yard/server/commands/static_file_helpers.rb#14 def favicon?; end # Attempts to route a path to a static template file. @@ -13409,20 +13402,20 @@ module YARD::Server::Commands::StaticFileHelpers # @return [void] # @since 0.6.0 # - # source://yard//lib/yard/server/commands/static_file_helpers.rb#27 + # source://yard//lib/yard/server/commands/static_file_helpers.rb#26 def static_template_file?; end private # @since 0.6.0 # - # source://yard//lib/yard/server/commands/static_file_helpers.rb#43 + # source://yard//lib/yard/server/commands/static_file_helpers.rb#42 def find_file(adapter, url); end class << self # @since 0.6.0 # - # source://yard//lib/yard/server/commands/static_file_helpers.rb#43 + # source://yard//lib/yard/server/commands/static_file_helpers.rb#42 def find_file(adapter, url); end end end @@ -13562,6 +13555,470 @@ end # source://yard//lib/yard/server/adapter.rb#6 class YARD::Server::FinishRequest < ::RuntimeError; end +# HTTPUtils provides utility methods for working with the HTTP protocol. +# +# This module is generally used internally by WEBrick +# +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#25 +module YARD::Server::HTTPUtils + private + + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#443 + def _escape(str, regex); end + + # :stopdoc: + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#441 + def _make_regex(str); end + + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#442 + def _make_regex!(str); end + + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#449 + def _unescape(str, regex); end + + # Removes quotes and escapes from +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#223 + def dequote(str); end + + # Escapes HTTP reserved and unwise characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#467 + def escape(str); end + + # Escapes 8 bit characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#508 + def escape8bit(str); end + + # Escapes form reserved characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#481 + def escape_form(str); end + + # Escapes path +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#497 + def escape_path(str); end + + # Loads Apache-compatible mime.types in +file+. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#112 + def load_mime_types(file); end + + # Returns the mime type of +filename+ from the list in +mime_tab+. If no + # mime type was found application/octet-stream is returned. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#134 + def mime_type(filename, mime_tab); end + + # Normalizes a request path. Raises an exception if the path cannot be + # normalized. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#31 + def normalize_path(path); end + + # Parses form data in +io+ with the given +boundary+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#395 + def parse_form_data(io, boundary); end + + # Parses an HTTP header +raw+ into a hash of header fields with an Array + # of values. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#145 + def parse_header(raw); end + + # Parses the query component of a URI in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#371 + def parse_query(str); end + + # Parses q values in +value+ as used in Accept headers. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#202 + def parse_qvalues(value); end + + # Parses a Range header value +ranges_specifier+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#184 + def parse_range_header(ranges_specifier); end + + # Quotes and escapes quotes in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#233 + def quote(str); end + + # Splits a header value +str+ according to HTTP specification. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#175 + def split_header_value(str); end + + # Unescapes HTTP reserved and unwise characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#474 + def unescape(str); end + + # Unescapes form reserved characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#490 + def unescape_form(str); end + + class << self + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#443 + def _escape(str, regex); end + + # :stopdoc: + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#441 + def _make_regex(str); end + + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#442 + def _make_regex!(str); end + + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#449 + def _unescape(str, regex); end + + # Removes quotes and escapes from +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#223 + def dequote(str); end + + # Escapes HTTP reserved and unwise characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#467 + def escape(str); end + + # Escapes 8 bit characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#508 + def escape8bit(str); end + + # Escapes form reserved characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#481 + def escape_form(str); end + + # Escapes path +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#497 + def escape_path(str); end + + # Loads Apache-compatible mime.types in +file+. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#112 + def load_mime_types(file); end + + # Returns the mime type of +filename+ from the list in +mime_tab+. If no + # mime type was found application/octet-stream is returned. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#134 + def mime_type(filename, mime_tab); end + + # Normalizes a request path. Raises an exception if the path cannot be + # normalized. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#31 + def normalize_path(path); end + + # Parses form data in +io+ with the given +boundary+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#395 + def parse_form_data(io, boundary); end + + # Parses an HTTP header +raw+ into a hash of header fields with an Array + # of values. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#145 + def parse_header(raw); end + + # Parses the query component of a URI in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#371 + def parse_query(str); end + + # Parses q values in +value+ as used in Accept headers. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#202 + def parse_qvalues(value); end + + # Parses a Range header value +ranges_specifier+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#184 + def parse_range_header(ranges_specifier); end + + # Quotes and escapes quotes in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#233 + def quote(str); end + + # Splits a header value +str+ according to HTTP specification. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#175 + def split_header_value(str); end + + # Unescapes HTTP reserved and unwise characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#474 + def unescape(str); end + + # Unescapes form reserved characters in +str+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#490 + def unescape_form(str); end + end +end + +# Default mime types +# +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#47 +YARD::Server::HTTPUtils::DefaultMimeTypes = T.let(T.unsafe(nil), Hash) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#459 +YARD::Server::HTTPUtils::ESCAPED = T.let(T.unsafe(nil), Regexp) + +# Stores multipart form data. FormData objects are created when +# WEBrick::HTTPUtils.parse_form_data is called. +# +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#242 +class YARD::Server::HTTPUtils::FormData < ::String + # Creates a new FormData object. + # + # +args+ is an Array of form data entries. One FormData will be created + # for each entry. + # + # This is called by WEBrick::HTTPUtils.parse_form_data for you + # + # @return [FormData] a new instance of FormData + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#267 + def initialize(*args); end + + # Adds +str+ to this FormData which may be the body, a header or a + # header entry. + # + # This is called by WEBrick::HTTPUtils.parse_form_data for you + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#300 + def <<(str); end + + # Retrieves the header at the first entry in +key+ + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#286 + def [](*key); end + + # Adds +data+ at the end of the chain of entries + # + # This is called by WEBrick::HTTPUtils.parse_form_data for you. + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#320 + def append_data(data); end + + # Yields each entry in this FormData + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#335 + def each_data; end + + # The filename of the form data part + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#254 + def filename; end + + # The filename of the form data part + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#254 + def filename=(_arg0); end + + # Returns all the FormData as an Array + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#347 + def list; end + + # The name of the form data part + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#249 + def name; end + + # The name of the form data part + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#249 + def name=(_arg0); end + + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#256 + def next_data=(_arg0); end + + # Returns all the FormData as an Array + # A FormData will behave like an Array + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#347 + def to_ary; end + + # This FormData's body + # + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#363 + def to_s; end + + protected + + # @since 0.6.0 + # + # source://yard//lib/yard/server/http_utils.rb#256 + def next_data; end +end + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#244 +YARD::Server::HTTPUtils::FormData::EmptyHeader = T.let(T.unsafe(nil), Hash) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#243 +YARD::Server::HTTPUtils::FormData::EmptyRawHeader = T.let(T.unsafe(nil), Array) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#458 +YARD::Server::HTTPUtils::NONASCII = T.let(T.unsafe(nil), Regexp) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#456 +YARD::Server::HTTPUtils::UNESCAPED = T.let(T.unsafe(nil), Regexp) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#457 +YARD::Server::HTTPUtils::UNESCAPED_FORM = T.let(T.unsafe(nil), Regexp) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#460 +YARD::Server::HTTPUtils::UNESCAPED_PCHAR = T.let(T.unsafe(nil), Regexp) + +# @since 0.6.0 +# +# source://yard//lib/yard/server/http_utils.rb#17 +YARD::Server::LF = T.let(T.unsafe(nil), String) + # This exception is raised when {LibraryVersion#prepare!} fails, or discovers # that the library is not "prepared" to be served by # @@ -14098,50 +14555,6 @@ module YARD::Server::StaticCaching def check_static_cache; end end -# The main adapter to initialize a WEBrick server. -# -# @since 0.6.0 -# -# source://yard//lib/yard/server/webrick_adapter.rb#9 -class YARD::Server::WebrickAdapter < ::YARD::Server::Adapter - # Initializes a WEBrick server. If {Adapter#server_options} contains a - # +:daemonize+ key set to true, the server will be daemonized. - # - # @since 0.6.0 - # - # source://yard//lib/yard/server/webrick_adapter.rb#10 - def start; end -end - -# The main WEBrick servlet implementation, accepting only GET requests. -# -# @since 0.6.0 -# -# source://yard//lib/yard/server/webrick_adapter.rb#20 -class YARD::Server::WebrickServlet < ::WEBrick::HTTPServlet::AbstractServlet - # @return [WebrickServlet] a new instance of WebrickServlet - # @since 0.6.0 - # - # source://yard//lib/yard/server/webrick_adapter.rb#23 - def initialize(server, adapter); end - - # @since 0.6.0 - # - # source://yard//lib/yard/server/webrick_adapter.rb#21 - def adapter; end - - # @since 0.6.0 - # - # source://yard//lib/yard/server/webrick_adapter.rb#21 - def adapter=(_arg0); end - - # @private - # @since 0.6.0 - # - # source://yard//lib/yard/server/webrick_adapter.rb#29 - def do_GET(request, response); end -end - # Stubs marshal dumps and acts a delegate class for an object by path # # @private @@ -14178,7 +14591,7 @@ YARD::TEMPLATE_ROOT = T.let(T.unsafe(nil), String) # Namespace for Tag components # -# source://yard//lib/yard/autoload.rb#247 +# source://yard//lib/yard/autoload.rb#248 module YARD::Tags; end # Defines an attribute with a given name, using indented block data as the @@ -15655,10 +16068,10 @@ class YARD::Tags::Tag def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil)); end # Provides a plain English summary of the type specification, or nil - # if no types are provided or parseable. + # if no types are provided or parsable. # # @return [String] a plain English description of the associated types - # @return [nil] if no types are provided or not parseable + # @return [nil] if no types are provided or not parsable # # source://yard//lib/yard/tags/tag.rb#65 def explain_types; end @@ -15734,25 +16147,29 @@ class YARD::Tags::TagFormatError < ::RuntimeError; end class YARD::Tags::TypesExplainer class << self # Provides a plain English summary of the type specification, or nil - # if no types are provided or parseable. + # if no types are provided or parsable. # # @param types [Array] a list of types to parse and summarize # @return [String] a plain English description of the associated types - # @return [nil] if no types are provided or not parseable + # @return [nil] if no types are provided or not parsable # # source://yard//lib/yard/tags/types_explainer.rb#9 def explain(*types); end # Provides a plain English summary of the type specification, or nil - # if no types are provided or parseable. + # if no types are provided or parsable. # # @param types [Array] a list of types to parse and summarize - # @raise [SyntaxError] if the types are not parseable + # @raise [SyntaxError] if the types are not parsable # @return [String] a plain English description of the associated types - # @return [nil] if no types are provided or not parseable + # @return [nil] if no types are provided or not parsable # # source://yard//lib/yard/tags/types_explainer.rb#17 def explain!(*types); end + + private + + def new(*_arg0); end end end @@ -15908,7 +16325,7 @@ end # Namespace for templating system # -# source://yard//lib/yard/autoload.rb#270 +# source://yard//lib/yard/autoload.rb#271 module YARD::Templates; end # This module manages all creation, handling and rendering of {Template} @@ -16061,7 +16478,7 @@ end # Namespace for template helpers # -# source://yard//lib/yard/autoload.rb#271 +# source://yard//lib/yard/autoload.rb#272 module YARD::Templates::Helpers; end # The base helper module included in all templates. @@ -16696,7 +17113,7 @@ end # Namespace for markup providers # -# source://yard//lib/yard/autoload.rb#272 +# source://yard//lib/yard/autoload.rb#273 module YARD::Templates::Helpers::Markup; end # source://yard//lib/yard/templates/helpers/markup/rdoc_markdown.rb#13 @@ -17448,7 +17865,7 @@ end # # @see CLI::YardocOptions # -# source://yard//lib/yard/templates/template_options.rb#11 +# source://yard//lib/yard/templates/template_options.rb#10 class YARD::Templates::TemplateOptions < ::YARD::Options # @return [OpenStruct] an open struct containing any global state across all # generated objects in a template. diff --git a/sorbet/rbi/gems/yarp@0.10.0.rbi b/sorbet/rbi/gems/yarp@0.10.0.rbi new file mode 100644 index 00000000..f45a2f81 --- /dev/null +++ b/sorbet/rbi/gems/yarp@0.10.0.rbi @@ -0,0 +1,13316 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `yarp` gem. +# Please instead update this file by running `bin/tapioca gem yarp`. + +# This file is generated by the templates/template.rb script and should not be +# modified manually. See templates/lib/yarp/node.rb.erb +# if you are looking to modify the template +# +# source://yarp//lib/yarp.rb#3 +module YARP + class << self + # Mirror the YARP.dump API by using the serialization API. + def dump(*_arg0); end + + # Mirror the YARP.dump_file API by using the serialization API. + def dump_file(_arg0); end + + # Mirror the YARP.lex API by using the serialization API. + def lex(*_arg0); end + + # Returns an array of tokens that closely resembles that of the Ripper lexer. + # The only difference is that since we don't keep track of lexer state in the + # same way, it's going to always return the NONE state. + # + # source://yarp//lib/yarp/lex_compat.rb#804 + def lex_compat(source, filepath = T.unsafe(nil)); end + + # Mirror the YARP.lex_file API by using the serialization API. + def lex_file(_arg0); end + + # This lexes with the Ripper lex. It drops any space events but otherwise + # returns the same tokens. Raises SyntaxError if the syntax in source is + # invalid. + # + # source://yarp//lib/yarp/lex_compat.rb#811 + def lex_ripper(source); end + + # Load the serialized AST using the source as a reference into a tree. + # + # source://yarp//lib/yarp.rb#361 + def load(source, serialized); end + + # Mirror the YARP.parse API by using the serialization API. + def parse(*_arg0); end + + # Mirror the YARP.parse_file API by using the serialization API. This uses + # native strings instead of Ruby strings because it allows us to use mmap when + # it is available. + def parse_file(_arg0); end + + # Mirror the YARP.parse_lex API by using the serialization API. + def parse_lex(*_arg0); end + + # Mirror the YARP.parse_lex_file API by using the serialization API. + def parse_lex_file(_arg0); end + end +end + +# Represents the use of the `alias` keyword. +# +# alias foo bar +# ^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#13 +class YARP::AliasNode < ::YARP::Node + # def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void + # + # @return [AliasNode] a new instance of AliasNode + # + # source://yarp//lib/yarp/node.rb#24 + def initialize(new_name, old_name, keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#32 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#37 + def child_nodes; end + + # def copy: (**params) -> AliasNode + # + # source://yarp//lib/yarp/node.rb#42 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#37 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#55 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#60 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#21 + def keyword_loc; end + + # attr_reader new_name: Node + # + # source://yarp//lib/yarp/node.rb#15 + def new_name; end + + # attr_reader old_name: Node + # + # source://yarp//lib/yarp/node.rb#18 + def old_name; end +end + +# Represents an alternation pattern in pattern matching. +# +# foo => bar | baz +# ^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#69 +class YARP::AlternationPatternNode < ::YARP::Node + # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void + # + # @return [AlternationPatternNode] a new instance of AlternationPatternNode + # + # source://yarp//lib/yarp/node.rb#80 + def initialize(left, right, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#88 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#93 + def child_nodes; end + + # def copy: (**params) -> AlternationPatternNode + # + # source://yarp//lib/yarp/node.rb#98 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#93 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#111 + def deconstruct_keys(keys); end + + # attr_reader left: Node + # + # source://yarp//lib/yarp/node.rb#71 + def left; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#116 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#77 + def operator_loc; end + + # attr_reader right: Node + # + # source://yarp//lib/yarp/node.rb#74 + def right; end +end + +# Represents the use of the `&&` operator or the `and` keyword. +# +# left and right +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#125 +class YARP::AndNode < ::YARP::Node + # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void + # + # @return [AndNode] a new instance of AndNode + # + # source://yarp//lib/yarp/node.rb#136 + def initialize(left, right, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#144 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#149 + def child_nodes; end + + # def copy: (**params) -> AndNode + # + # source://yarp//lib/yarp/node.rb#154 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#149 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#167 + def deconstruct_keys(keys); end + + # attr_reader left: Node + # + # source://yarp//lib/yarp/node.rb#127 + def left; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#172 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#133 + def operator_loc; end + + # attr_reader right: Node + # + # source://yarp//lib/yarp/node.rb#130 + def right; end +end + +# Represents a set of arguments to a method or a keyword. +# +# return foo, bar, baz +# ^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#181 +class YARP::ArgumentsNode < ::YARP::Node + # def initialize: (arguments: Array[Node], location: Location) -> void + # + # @return [ArgumentsNode] a new instance of ArgumentsNode + # + # source://yarp//lib/yarp/node.rb#186 + def initialize(arguments, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#192 + def accept(visitor); end + + # attr_reader arguments: Array[Node] + # + # source://yarp//lib/yarp/node.rb#183 + def arguments; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#197 + def child_nodes; end + + # def copy: (**params) -> ArgumentsNode + # + # source://yarp//lib/yarp/node.rb#202 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#197 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#213 + def deconstruct_keys(keys); end +end + +# Represents an array literal. This can be a regular array using brackets or +# a special array using % like %w or %i. +# +# [1, 2, 3] +# ^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#223 +class YARP::ArrayNode < ::YARP::Node + # def initialize: (elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void + # + # @return [ArrayNode] a new instance of ArrayNode + # + # source://yarp//lib/yarp/node.rb#234 + def initialize(elements, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#242 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#247 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#275 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#231 + def closing_loc; end + + # def copy: (**params) -> ArrayNode + # + # source://yarp//lib/yarp/node.rb#252 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#247 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#265 + def deconstruct_keys(keys); end + + # attr_reader elements: Array[Node] + # + # source://yarp//lib/yarp/node.rb#225 + def elements; end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#270 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#228 + def opening_loc; end +end + +# Represents an array pattern in pattern matching. +# +# foo in 1, 2 +# ^^^^^^^^^^^ +# +# foo in [1, 2] +# ^^^^^^^^^^^^^ +# +# foo in *1 +# ^^^^^^^^^ +# +# foo in Bar[] +# ^^^^^^^^^^^^ +# +# foo in Bar[1, 2, 3] +# ^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#296 +class YARP::ArrayPatternNode < ::YARP::Node + # def initialize: (constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void + # + # @return [ArrayPatternNode] a new instance of ArrayPatternNode + # + # source://yarp//lib/yarp/node.rb#316 + def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#327 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#332 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#363 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#313 + def closing_loc; end + + # attr_reader constant: Node? + # + # source://yarp//lib/yarp/node.rb#298 + def constant; end + + # def copy: (**params) -> ArrayPatternNode + # + # source://yarp//lib/yarp/node.rb#337 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#332 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#353 + def deconstruct_keys(keys); end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#358 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#310 + def opening_loc; end + + # attr_reader posts: Array[Node] + # + # source://yarp//lib/yarp/node.rb#307 + def posts; end + + # attr_reader requireds: Array[Node] + # + # source://yarp//lib/yarp/node.rb#301 + def requireds; end + + # attr_reader rest: Node? + # + # source://yarp//lib/yarp/node.rb#304 + def rest; end +end + +# Represents a hash key/value pair. +# +# { a => b } +# ^^^^^^ +# +# source://yarp//lib/yarp/node.rb#372 +class YARP::AssocNode < ::YARP::Node + # def initialize: (key: Node, value: Node?, operator_loc: Location?, location: Location) -> void + # + # @return [AssocNode] a new instance of AssocNode + # + # source://yarp//lib/yarp/node.rb#383 + def initialize(key, value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#391 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#396 + def child_nodes; end + + # def copy: (**params) -> AssocNode + # + # source://yarp//lib/yarp/node.rb#401 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#396 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#414 + def deconstruct_keys(keys); end + + # attr_reader key: Node + # + # source://yarp//lib/yarp/node.rb#374 + def key; end + + # def operator: () -> String? + # + # source://yarp//lib/yarp/node.rb#419 + def operator; end + + # attr_reader operator_loc: Location? + # + # source://yarp//lib/yarp/node.rb#380 + def operator_loc; end + + # attr_reader value: Node? + # + # source://yarp//lib/yarp/node.rb#377 + def value; end +end + +# Represents a splat in a hash literal. +# +# { **foo } +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#428 +class YARP::AssocSplatNode < ::YARP::Node + # def initialize: (value: Node?, operator_loc: Location, location: Location) -> void + # + # @return [AssocSplatNode] a new instance of AssocSplatNode + # + # source://yarp//lib/yarp/node.rb#436 + def initialize(value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#443 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#448 + def child_nodes; end + + # def copy: (**params) -> AssocSplatNode + # + # source://yarp//lib/yarp/node.rb#453 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#448 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#465 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#470 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#433 + def operator_loc; end + + # attr_reader value: Node? + # + # source://yarp//lib/yarp/node.rb#430 + def value; end +end + +YARP::BACKEND = T.let(T.unsafe(nil), Symbol) + +# Represents reading a reference to a field in the previous match. +# +# $' +# ^^ +# +# source://yarp//lib/yarp/node.rb#479 +class YARP::BackReferenceReadNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode + # + # source://yarp//lib/yarp/node.rb#481 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#486 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#491 + def child_nodes; end + + # def copy: (**params) -> BackReferenceReadNode + # + # source://yarp//lib/yarp/node.rb#496 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#491 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#506 + def deconstruct_keys(keys); end +end + +# A class that knows how to walk down the tree. None of the individual visit +# methods are implemented on this visitor, so it forces the consumer to +# implement each one that they need. For a default implementation that +# continues walking the tree, see the Visitor class. +# +# source://yarp//lib/yarp.rb#178 +class YARP::BasicVisitor + # source://yarp//lib/yarp.rb#179 + def visit(node); end + + # source://yarp//lib/yarp.rb#183 + def visit_all(nodes); end + + # source://yarp//lib/yarp.rb#187 + def visit_child_nodes(node); end +end + +# Represents a begin statement. +# +# begin +# foo +# end +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#517 +class YARP::BeginNode < ::YARP::Node + # def initialize: (begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location) -> void + # + # @return [BeginNode] a new instance of BeginNode + # + # source://yarp//lib/yarp/node.rb#537 + def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#548 + def accept(visitor); end + + # def begin_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#583 + def begin_keyword; end + + # attr_reader begin_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#519 + def begin_keyword_loc; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#557 + def child_nodes; end + + # def copy: (**params) -> BeginNode + # + # source://yarp//lib/yarp/node.rb#562 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#557 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#578 + def deconstruct_keys(keys); end + + # attr_reader else_clause: ElseNode? + # + # source://yarp//lib/yarp/node.rb#528 + def else_clause; end + + # def end_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#588 + def end_keyword; end + + # attr_reader end_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#534 + def end_keyword_loc; end + + # attr_reader ensure_clause: EnsureNode? + # + # source://yarp//lib/yarp/node.rb#531 + def ensure_clause; end + + # attr_reader rescue_clause: RescueNode? + # + # source://yarp//lib/yarp/node.rb#525 + def rescue_clause; end + + # source://yarp//lib/yarp/node.rb#552 + def set_newline_flag(newline_marked); end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#522 + def statements; end +end + +# Represents block method arguments. +# +# bar(&args) +# ^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#597 +class YARP::BlockArgumentNode < ::YARP::Node + # def initialize: (expression: Node?, operator_loc: Location, location: Location) -> void + # + # @return [BlockArgumentNode] a new instance of BlockArgumentNode + # + # source://yarp//lib/yarp/node.rb#605 + def initialize(expression, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#612 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#617 + def child_nodes; end + + # def copy: (**params) -> BlockArgumentNode + # + # source://yarp//lib/yarp/node.rb#622 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#617 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#634 + def deconstruct_keys(keys); end + + # attr_reader expression: Node? + # + # source://yarp//lib/yarp/node.rb#599 + def expression; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#639 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#602 + def operator_loc; end +end + +# Represents a block of ruby code. +# +# [1, 2, 3].each { |i| puts x } +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#648 +class YARP::BlockNode < ::YARP::Node + # def initialize: (locals: Array[Symbol], parameters: BlockParametersNode?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void + # + # @return [BlockNode] a new instance of BlockNode + # + # source://yarp//lib/yarp/node.rb#665 + def initialize(locals, parameters, body, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#675 + def accept(visitor); end + + # attr_reader body: Node? + # + # source://yarp//lib/yarp/node.rb#656 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#680 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#710 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#662 + def closing_loc; end + + # def copy: (**params) -> BlockNode + # + # source://yarp//lib/yarp/node.rb#685 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#680 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#700 + def deconstruct_keys(keys); end + + # attr_reader locals: Array[Symbol] + # + # source://yarp//lib/yarp/node.rb#650 + def locals; end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#705 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#659 + def opening_loc; end + + # attr_reader parameters: BlockParametersNode? + # + # source://yarp//lib/yarp/node.rb#653 + def parameters; end +end + +# Represents a block parameter to a method, block, or lambda definition. +# +# def a(&b) +# ^^ +# end +# +# source://yarp//lib/yarp/node.rb#720 +class YARP::BlockParameterNode < ::YARP::Node + # def initialize: (name_loc: Location?, operator_loc: Location, location: Location) -> void + # + # @return [BlockParameterNode] a new instance of BlockParameterNode + # + # source://yarp//lib/yarp/node.rb#728 + def initialize(name_loc, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#735 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#740 + def child_nodes; end + + # def copy: (**params) -> BlockParameterNode + # + # source://yarp//lib/yarp/node.rb#745 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#740 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#757 + def deconstruct_keys(keys); end + + # def name: () -> String? + # + # source://yarp//lib/yarp/node.rb#762 + def name; end + + # attr_reader name_loc: Location? + # + # source://yarp//lib/yarp/node.rb#722 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#767 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#725 + def operator_loc; end +end + +# Represents a block's parameters declaration. +# +# -> (a, b = 1; local) { } +# ^^^^^^^^^^^^^^^^^ +# +# foo do |a, b = 1; local| +# ^^^^^^^^^^^^^^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#780 +class YARP::BlockParametersNode < ::YARP::Node + # def initialize: (parameters: ParametersNode?, locals: Array[Location], opening_loc: Location?, closing_loc: Location?, location: Location) -> void + # + # @return [BlockParametersNode] a new instance of BlockParametersNode + # + # source://yarp//lib/yarp/node.rb#794 + def initialize(parameters, locals, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#803 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#808 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#837 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#791 + def closing_loc; end + + # def copy: (**params) -> BlockParametersNode + # + # source://yarp//lib/yarp/node.rb#813 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#808 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#827 + def deconstruct_keys(keys); end + + # attr_reader locals: Array[Location] + # + # source://yarp//lib/yarp/node.rb#785 + def locals; end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#832 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#788 + def opening_loc; end + + # attr_reader parameters: ParametersNode? + # + # source://yarp//lib/yarp/node.rb#782 + def parameters; end +end + +# Represents the use of the `break` keyword. +# +# break foo +# ^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#846 +class YARP::BreakNode < ::YARP::Node + # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void + # + # @return [BreakNode] a new instance of BreakNode + # + # source://yarp//lib/yarp/node.rb#854 + def initialize(arguments, keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#861 + def accept(visitor); end + + # attr_reader arguments: ArgumentsNode? + # + # source://yarp//lib/yarp/node.rb#848 + def arguments; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#866 + def child_nodes; end + + # def copy: (**params) -> BreakNode + # + # source://yarp//lib/yarp/node.rb#871 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#866 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#883 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#888 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#851 + def keyword_loc; end +end + +# Represents a method call, in all of the various forms that can take. +# +# foo +# ^^^ +# +# foo() +# ^^^^^ +# +# +foo +# ^^^^ +# +# foo + bar +# ^^^^^^^^^ +# +# foo.bar +# ^^^^^^^ +# +# foo&.bar +# ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#912 +class YARP::CallNode < ::YARP::Node + # def initialize: (receiver: Node?, operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode?, flags: Integer, name: String, location: Location) -> void + # + # @return [CallNode] a new instance of CallNode + # + # source://yarp//lib/yarp/node.rb#941 + def initialize(receiver, operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#955 + def accept(visitor); end + + # attr_reader arguments: ArgumentsNode? + # + # source://yarp//lib/yarp/node.rb#926 + def arguments; end + + # attr_reader block: BlockNode? + # + # source://yarp//lib/yarp/node.rb#932 + def block; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#960 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#1004 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#929 + def closing_loc; end + + # def copy: (**params) -> CallNode + # + # source://yarp//lib/yarp/node.rb#965 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#960 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#984 + def deconstruct_keys(keys); end + + # attr_reader flags: Integer + # + # source://yarp//lib/yarp/node.rb#935 + def flags; end + + # def message: () -> String? + # + # source://yarp//lib/yarp/node.rb#994 + def message; end + + # attr_reader message_loc: Location? + # + # source://yarp//lib/yarp/node.rb#920 + def message_loc; end + + # attr_reader name: String + # + # source://yarp//lib/yarp/node.rb#938 + def name; end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#999 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#923 + def opening_loc; end + + # def operator: () -> String? + # + # source://yarp//lib/yarp/node.rb#989 + def operator; end + + # attr_reader operator_loc: Location? + # + # source://yarp//lib/yarp/node.rb#917 + def operator_loc; end + + # attr_reader receiver: Node? + # + # source://yarp//lib/yarp/node.rb#914 + def receiver; end + + # def safe_navigation?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#1009 + def safe_navigation?; end + + # def variable_call?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#1014 + def variable_call?; end +end + +# source://yarp//lib/yarp/node.rb#7983 +module YARP::CallNodeFlags; end + +# &. operator +# +# source://yarp//lib/yarp/node.rb#7985 +YARP::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer) + +# a call that could have been a local variable +# +# source://yarp//lib/yarp/node.rb#7988 +YARP::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer) + +# Represents the use of the `&&=` operator on a call. +# +# foo.bar &&= value +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1023 +class YARP::CallOperatorAndWriteNode < ::YARP::Node + # def initialize: (target: CallNode, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [CallOperatorAndWriteNode] a new instance of CallOperatorAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1034 + def initialize(target, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1042 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1047 + def child_nodes; end + + # def copy: (**params) -> CallOperatorAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1052 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1047 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1065 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1070 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1028 + def operator_loc; end + + # attr_reader target: CallNode + # + # source://yarp//lib/yarp/node.rb#1025 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1031 + def value; end +end + +# Represents the use of the `||=` operator on a call. +# +# foo.bar ||= value +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1079 +class YARP::CallOperatorOrWriteNode < ::YARP::Node + # def initialize: (target: CallNode, value: Node, operator_loc: Location, location: Location) -> void + # + # @return [CallOperatorOrWriteNode] a new instance of CallOperatorOrWriteNode + # + # source://yarp//lib/yarp/node.rb#1090 + def initialize(target, value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1098 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1103 + def child_nodes; end + + # def copy: (**params) -> CallOperatorOrWriteNode + # + # source://yarp//lib/yarp/node.rb#1108 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1103 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1121 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1126 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1087 + def operator_loc; end + + # attr_reader target: CallNode + # + # source://yarp//lib/yarp/node.rb#1081 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1084 + def value; end +end + +# Represents the use of an assignment operator on a call. +# +# foo.bar += baz +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1135 +class YARP::CallOperatorWriteNode < ::YARP::Node + # def initialize: (target: CallNode, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void + # + # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#1149 + def initialize(target, operator_loc, value, operator, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1158 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1163 + def child_nodes; end + + # def copy: (**params) -> CallOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#1168 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1163 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1182 + def deconstruct_keys(keys); end + + # attr_reader operator: Symbol + # + # source://yarp//lib/yarp/node.rb#1146 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1140 + def operator_loc; end + + # attr_reader target: CallNode + # + # source://yarp//lib/yarp/node.rb#1137 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1143 + def value; end +end + +# Represents assigning to a local variable in pattern matching. +# +# foo => [bar => baz] +# ^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1191 +class YARP::CapturePatternNode < ::YARP::Node + # def initialize: (value: Node, target: Node, operator_loc: Location, location: Location) -> void + # + # @return [CapturePatternNode] a new instance of CapturePatternNode + # + # source://yarp//lib/yarp/node.rb#1202 + def initialize(value, target, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1210 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1215 + def child_nodes; end + + # def copy: (**params) -> CapturePatternNode + # + # source://yarp//lib/yarp/node.rb#1220 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1215 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1233 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1238 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1199 + def operator_loc; end + + # attr_reader target: Node + # + # source://yarp//lib/yarp/node.rb#1196 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1193 + def value; end +end + +# Represents the use of a case statement. +# +# case true +# ^^^^^^^^^ +# when false +# end +# +# source://yarp//lib/yarp/node.rb#1249 +class YARP::CaseNode < ::YARP::Node + # def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void + # + # @return [CaseNode] a new instance of CaseNode + # + # source://yarp//lib/yarp/node.rb#1266 + def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1276 + def accept(visitor); end + + # def case_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#1306 + def case_keyword; end + + # attr_reader case_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#1260 + def case_keyword_loc; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1281 + def child_nodes; end + + # attr_reader conditions: Array[Node] + # + # source://yarp//lib/yarp/node.rb#1254 + def conditions; end + + # attr_reader consequent: ElseNode? + # + # source://yarp//lib/yarp/node.rb#1257 + def consequent; end + + # def copy: (**params) -> CaseNode + # + # source://yarp//lib/yarp/node.rb#1286 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1281 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1301 + def deconstruct_keys(keys); end + + # def end_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#1311 + def end_keyword; end + + # attr_reader end_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#1263 + def end_keyword_loc; end + + # attr_reader predicate: Node? + # + # source://yarp//lib/yarp/node.rb#1251 + def predicate; end +end + +# Represents a class declaration involving the `class` keyword. +# +# class Foo end +# ^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1320 +class YARP::ClassNode < ::YARP::Node + # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: String, location: Location) -> void + # + # @return [ClassNode] a new instance of ClassNode + # + # source://yarp//lib/yarp/node.rb#1346 + def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1359 + def accept(visitor); end + + # attr_reader body: Node? + # + # source://yarp//lib/yarp/node.rb#1337 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1364 + def child_nodes; end + + # def class_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#1392 + def class_keyword; end + + # attr_reader class_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#1325 + def class_keyword_loc; end + + # attr_reader constant_path: Node + # + # source://yarp//lib/yarp/node.rb#1328 + def constant_path; end + + # def copy: (**params) -> ClassNode + # + # source://yarp//lib/yarp/node.rb#1369 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1364 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1387 + def deconstruct_keys(keys); end + + # def end_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#1402 + def end_keyword; end + + # attr_reader end_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#1340 + def end_keyword_loc; end + + # def inheritance_operator: () -> String? + # + # source://yarp//lib/yarp/node.rb#1397 + def inheritance_operator; end + + # attr_reader inheritance_operator_loc: Location? + # + # source://yarp//lib/yarp/node.rb#1331 + def inheritance_operator_loc; end + + # attr_reader locals: Array[Symbol] + # + # source://yarp//lib/yarp/node.rb#1322 + def locals; end + + # attr_reader name: String + # + # source://yarp//lib/yarp/node.rb#1343 + def name; end + + # attr_reader superclass: Node? + # + # source://yarp//lib/yarp/node.rb#1334 + def superclass; end +end + +# Represents the use of the `&&=` operator for assignment to a class variable. +# +# @@target &&= value +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1411 +class YARP::ClassVariableAndWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1425 + def initialize(name, name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1434 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1439 + def child_nodes; end + + # def copy: (**params) -> ClassVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1444 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1439 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1458 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#1413 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#1416 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1463 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1419 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1422 + def value; end +end + +# Represents assigning to a class variable using an operator that isn't `=`. +# +# @@target += value +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1472 +class YARP::ClassVariableOperatorWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void + # + # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#1489 + def initialize(name, name_loc, operator_loc, value, operator, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1499 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1504 + def child_nodes; end + + # def copy: (**params) -> ClassVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#1509 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1504 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1524 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#1474 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#1477 + def name_loc; end + + # attr_reader operator: Symbol + # + # source://yarp//lib/yarp/node.rb#1486 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1480 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1483 + def value; end +end + +# Represents the use of the `||=` operator for assignment to a class variable. +# +# @@target ||= value +# ^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1533 +class YARP::ClassVariableOrWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#1547 + def initialize(name, name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1556 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1561 + def child_nodes; end + + # def copy: (**params) -> ClassVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#1566 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1561 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1580 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#1535 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#1538 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1585 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1541 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1544 + def value; end +end + +# Represents referencing a class variable. +# +# @@foo +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#1594 +class YARP::ClassVariableReadNode < ::YARP::Node + # def initialize: (name: Symbol, location: Location) -> void + # + # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode + # + # source://yarp//lib/yarp/node.rb#1599 + def initialize(name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1605 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1610 + def child_nodes; end + + # def copy: (**params) -> ClassVariableReadNode + # + # source://yarp//lib/yarp/node.rb#1615 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1610 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1626 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#1596 + def name; end +end + +# Represents writing to a class variable in a context that doesn't have an explicit value. +# +# @@foo, @@bar = baz +# ^^^^^ ^^^^^ +# +# source://yarp//lib/yarp/node.rb#1635 +class YARP::ClassVariableTargetNode < ::YARP::Node + # def initialize: (name: Symbol, location: Location) -> void + # + # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#1640 + def initialize(name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1646 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1651 + def child_nodes; end + + # def copy: (**params) -> ClassVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#1656 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1651 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1667 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#1637 + def name; end +end + +# Represents writing to a class variable. +# +# @@foo = 1 +# ^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1676 +class YARP::ClassVariableWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, value: Node?, operator_loc: Location?, location: Location) -> void + # + # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#1690 + def initialize(name, name_loc, value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1699 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1704 + def child_nodes; end + + # def copy: (**params) -> ClassVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#1709 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1704 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1723 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#1678 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#1681 + def name_loc; end + + # def operator: () -> String? + # + # source://yarp//lib/yarp/node.rb#1728 + def operator; end + + # attr_reader operator_loc: Location? + # + # source://yarp//lib/yarp/node.rb#1687 + def operator_loc; end + + # attr_reader value: Node? + # + # source://yarp//lib/yarp/node.rb#1684 + def value; end +end + +# This represents a comment that was encountered during parsing. +# +# source://yarp//lib/yarp.rb#131 +class YARP::Comment + # @return [Comment] a new instance of Comment + # + # source://yarp//lib/yarp.rb#136 + def initialize(type, location); end + + # source://yarp//lib/yarp.rb#141 + def deconstruct_keys(keys); end + + # Returns the value of attribute location. + # + # source://yarp//lib/yarp.rb#134 + def location; end + + # Returns the value of attribute type. + # + # source://yarp//lib/yarp.rb#134 + def type; end +end + +# source://yarp//lib/yarp.rb#132 +YARP::Comment::TYPES = T.let(T.unsafe(nil), Array) + +# Represents the use of the `&&=` operator for assignment to a constant. +# +# Target &&= value +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1737 +class YARP::ConstantAndWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1748 + def initialize(name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1756 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1761 + def child_nodes; end + + # def copy: (**params) -> ConstantAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1766 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1761 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1779 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#1784 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#1739 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1789 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1742 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1745 + def value; end +end + +# Represents assigning to a constant using an operator that isn't `=`. +# +# Target += value +# ^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1798 +class YARP::ConstantOperatorWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void + # + # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#1812 + def initialize(name_loc, operator_loc, value, operator, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1821 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1826 + def child_nodes; end + + # def copy: (**params) -> ConstantOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#1831 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1826 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1845 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#1850 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#1800 + def name_loc; end + + # attr_reader operator: Symbol + # + # source://yarp//lib/yarp/node.rb#1809 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1803 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1806 + def value; end +end + +# Represents the use of the `||=` operator for assignment to a constant. +# +# Target ||= value +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1859 +class YARP::ConstantOrWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode + # + # source://yarp//lib/yarp/node.rb#1870 + def initialize(name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1878 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1883 + def child_nodes; end + + # def copy: (**params) -> ConstantOrWriteNode + # + # source://yarp//lib/yarp/node.rb#1888 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1883 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1901 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#1906 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#1861 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1911 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1864 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1867 + def value; end +end + +# Represents the use of the `&&=` operator for assignment to a constant path. +# +# Parent::Child &&= value +# ^^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1920 +class YARP::ConstantPathAndWriteNode < ::YARP::Node + # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1931 + def initialize(target, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1939 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1944 + def child_nodes; end + + # def copy: (**params) -> ConstantPathAndWriteNode + # + # source://yarp//lib/yarp/node.rb#1949 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#1944 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#1962 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#1967 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#1925 + def operator_loc; end + + # attr_reader target: ConstantPathNode + # + # source://yarp//lib/yarp/node.rb#1922 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#1928 + def value; end +end + +# Represents accessing a constant through a path of `::` operators. +# +# Foo::Bar +# ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#1976 +class YARP::ConstantPathNode < ::YARP::Node + # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void + # + # @return [ConstantPathNode] a new instance of ConstantPathNode + # + # source://yarp//lib/yarp/node.rb#1987 + def initialize(parent, child, delimiter_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#1995 + def accept(visitor); end + + # attr_reader child: Node + # + # source://yarp//lib/yarp/node.rb#1981 + def child; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2000 + def child_nodes; end + + # def copy: (**params) -> ConstantPathNode + # + # source://yarp//lib/yarp/node.rb#2005 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2000 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2018 + def deconstruct_keys(keys); end + + # def delimiter: () -> String + # + # source://yarp//lib/yarp/node.rb#2023 + def delimiter; end + + # attr_reader delimiter_loc: Location + # + # source://yarp//lib/yarp/node.rb#1984 + def delimiter_loc; end + + # attr_reader parent: Node? + # + # source://yarp//lib/yarp/node.rb#1978 + def parent; end +end + +# Represents assigning to a constant path using an operator that isn't `=`. +# +# Parent::Child += value +# ^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2032 +class YARP::ConstantPathOperatorWriteNode < ::YARP::Node + # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void + # + # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#2046 + def initialize(target, operator_loc, value, operator, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2055 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2060 + def child_nodes; end + + # def copy: (**params) -> ConstantPathOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#2065 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2060 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2079 + def deconstruct_keys(keys); end + + # attr_reader operator: Symbol + # + # source://yarp//lib/yarp/node.rb#2043 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#2037 + def operator_loc; end + + # attr_reader target: ConstantPathNode + # + # source://yarp//lib/yarp/node.rb#2034 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#2040 + def value; end +end + +# Represents the use of the `||=` operator for assignment to a constant path. +# +# Parent::Child ||= value +# ^^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2088 +class YARP::ConstantPathOrWriteNode < ::YARP::Node + # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode + # + # source://yarp//lib/yarp/node.rb#2099 + def initialize(target, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2107 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2112 + def child_nodes; end + + # def copy: (**params) -> ConstantPathOrWriteNode + # + # source://yarp//lib/yarp/node.rb#2117 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2112 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2130 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#2135 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#2093 + def operator_loc; end + + # attr_reader target: ConstantPathNode + # + # source://yarp//lib/yarp/node.rb#2090 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#2096 + def value; end +end + +# Represents writing to a constant path in a context that doesn't have an explicit value. +# +# Foo::Foo, Bar::Bar = baz +# ^^^^^^^^ ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2144 +class YARP::ConstantPathTargetNode < ::YARP::Node + # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void + # + # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode + # + # source://yarp//lib/yarp/node.rb#2155 + def initialize(parent, child, delimiter_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2163 + def accept(visitor); end + + # attr_reader child: Node + # + # source://yarp//lib/yarp/node.rb#2149 + def child; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2168 + def child_nodes; end + + # def copy: (**params) -> ConstantPathTargetNode + # + # source://yarp//lib/yarp/node.rb#2173 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2168 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2186 + def deconstruct_keys(keys); end + + # def delimiter: () -> String + # + # source://yarp//lib/yarp/node.rb#2191 + def delimiter; end + + # attr_reader delimiter_loc: Location + # + # source://yarp//lib/yarp/node.rb#2152 + def delimiter_loc; end + + # attr_reader parent: Node? + # + # source://yarp//lib/yarp/node.rb#2146 + def parent; end +end + +# Represents writing to a constant path. +# +# ::Foo = 1 +# ^^^^^^^^^ +# +# Foo::Bar = 1 +# ^^^^^^^^^^^^ +# +# ::Foo::Bar = 1 +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2206 +class YARP::ConstantPathWriteNode < ::YARP::Node + # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode + # + # source://yarp//lib/yarp/node.rb#2217 + def initialize(target, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2225 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2230 + def child_nodes; end + + # def copy: (**params) -> ConstantPathWriteNode + # + # source://yarp//lib/yarp/node.rb#2235 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2230 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2248 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#2253 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#2211 + def operator_loc; end + + # attr_reader target: ConstantPathNode + # + # source://yarp//lib/yarp/node.rb#2208 + def target; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#2214 + def value; end +end + +# Represents referencing a constant. +# +# Foo +# ^^^ +# +# source://yarp//lib/yarp/node.rb#2262 +class YARP::ConstantReadNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [ConstantReadNode] a new instance of ConstantReadNode + # + # source://yarp//lib/yarp/node.rb#2264 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2269 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2274 + def child_nodes; end + + # def copy: (**params) -> ConstantReadNode + # + # source://yarp//lib/yarp/node.rb#2279 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2274 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2289 + def deconstruct_keys(keys); end +end + +# Represents writing to a constant in a context that doesn't have an explicit value. +# +# Foo, Bar = baz +# ^^^ ^^^ +# +# source://yarp//lib/yarp/node.rb#2298 +class YARP::ConstantTargetNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [ConstantTargetNode] a new instance of ConstantTargetNode + # + # source://yarp//lib/yarp/node.rb#2300 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2305 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2310 + def child_nodes; end + + # def copy: (**params) -> ConstantTargetNode + # + # source://yarp//lib/yarp/node.rb#2315 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2310 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2325 + def deconstruct_keys(keys); end +end + +# Represents writing to a constant. +# +# Foo = 1 +# ^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2334 +class YARP::ConstantWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void + # + # @return [ConstantWriteNode] a new instance of ConstantWriteNode + # + # source://yarp//lib/yarp/node.rb#2345 + def initialize(name_loc, value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2353 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2358 + def child_nodes; end + + # def copy: (**params) -> ConstantWriteNode + # + # source://yarp//lib/yarp/node.rb#2363 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2358 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2376 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#2381 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#2336 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#2386 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#2342 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#2339 + def value; end +end + +# source://yarp//lib/yarp/node.rb#8431 +module YARP::DSL + private + + # Create a new AliasNode node + # + # source://yarp//lib/yarp/node.rb#8440 + def AliasNode(new_name, old_name, keyword_loc, location = T.unsafe(nil)); end + + # Create a new AlternationPatternNode node + # + # source://yarp//lib/yarp/node.rb#8445 + def AlternationPatternNode(left, right, operator_loc, location = T.unsafe(nil)); end + + # Create a new AndNode node + # + # source://yarp//lib/yarp/node.rb#8450 + def AndNode(left, right, operator_loc, location = T.unsafe(nil)); end + + # Create a new ArgumentsNode node + # + # source://yarp//lib/yarp/node.rb#8455 + def ArgumentsNode(arguments, location = T.unsafe(nil)); end + + # Create a new ArrayNode node + # + # source://yarp//lib/yarp/node.rb#8460 + def ArrayNode(elements, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new ArrayPatternNode node + # + # source://yarp//lib/yarp/node.rb#8465 + def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new AssocNode node + # + # source://yarp//lib/yarp/node.rb#8470 + def AssocNode(key, value, operator_loc, location = T.unsafe(nil)); end + + # Create a new AssocSplatNode node + # + # source://yarp//lib/yarp/node.rb#8475 + def AssocSplatNode(value, operator_loc, location = T.unsafe(nil)); end + + # Create a new BackReferenceReadNode node + # + # source://yarp//lib/yarp/node.rb#8480 + def BackReferenceReadNode(location = T.unsafe(nil)); end + + # Create a new BeginNode node + # + # source://yarp//lib/yarp/node.rb#8485 + def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new BlockArgumentNode node + # + # source://yarp//lib/yarp/node.rb#8490 + def BlockArgumentNode(expression, operator_loc, location = T.unsafe(nil)); end + + # Create a new BlockNode node + # + # source://yarp//lib/yarp/node.rb#8495 + def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new BlockParameterNode node + # + # source://yarp//lib/yarp/node.rb#8500 + def BlockParameterNode(name_loc, operator_loc, location = T.unsafe(nil)); end + + # Create a new BlockParametersNode node + # + # source://yarp//lib/yarp/node.rb#8505 + def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new BreakNode node + # + # source://yarp//lib/yarp/node.rb#8510 + def BreakNode(arguments, keyword_loc, location = T.unsafe(nil)); end + + # Create a new CallNode node + # + # source://yarp//lib/yarp/node.rb#8515 + def CallNode(receiver, operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location = T.unsafe(nil)); end + + # Create a new CallOperatorAndWriteNode node + # + # source://yarp//lib/yarp/node.rb#8520 + def CallOperatorAndWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new CallOperatorOrWriteNode node + # + # source://yarp//lib/yarp/node.rb#8525 + def CallOperatorOrWriteNode(target, value, operator_loc, location = T.unsafe(nil)); end + + # Create a new CallOperatorWriteNode node + # + # source://yarp//lib/yarp/node.rb#8530 + def CallOperatorWriteNode(target, operator_loc, value, operator, location = T.unsafe(nil)); end + + # Create a new CapturePatternNode node + # + # source://yarp//lib/yarp/node.rb#8535 + def CapturePatternNode(value, target, operator_loc, location = T.unsafe(nil)); end + + # Create a new CaseNode node + # + # source://yarp//lib/yarp/node.rb#8540 + def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new ClassNode node + # + # source://yarp//lib/yarp/node.rb#8545 + def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = T.unsafe(nil)); end + + # Create a new ClassVariableAndWriteNode node + # + # source://yarp//lib/yarp/node.rb#8550 + def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new ClassVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/node.rb#8555 + def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end + + # Create a new ClassVariableOrWriteNode node + # + # source://yarp//lib/yarp/node.rb#8560 + def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new ClassVariableReadNode node + # + # source://yarp//lib/yarp/node.rb#8565 + def ClassVariableReadNode(name, location = T.unsafe(nil)); end + + # Create a new ClassVariableTargetNode node + # + # source://yarp//lib/yarp/node.rb#8570 + def ClassVariableTargetNode(name, location = T.unsafe(nil)); end + + # Create a new ClassVariableWriteNode node + # + # source://yarp//lib/yarp/node.rb#8575 + def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end + + # Create a new ConstantAndWriteNode node + # + # source://yarp//lib/yarp/node.rb#8580 + def ConstantAndWriteNode(name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new ConstantOperatorWriteNode node + # + # source://yarp//lib/yarp/node.rb#8585 + def ConstantOperatorWriteNode(name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end + + # Create a new ConstantOrWriteNode node + # + # source://yarp//lib/yarp/node.rb#8590 + def ConstantOrWriteNode(name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new ConstantPathAndWriteNode node + # + # source://yarp//lib/yarp/node.rb#8595 + def ConstantPathAndWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new ConstantPathNode node + # + # source://yarp//lib/yarp/node.rb#8600 + def ConstantPathNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end + + # Create a new ConstantPathOperatorWriteNode node + # + # source://yarp//lib/yarp/node.rb#8605 + def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = T.unsafe(nil)); end + + # Create a new ConstantPathOrWriteNode node + # + # source://yarp//lib/yarp/node.rb#8610 + def ConstantPathOrWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new ConstantPathTargetNode node + # + # source://yarp//lib/yarp/node.rb#8615 + def ConstantPathTargetNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end + + # Create a new ConstantPathWriteNode node + # + # source://yarp//lib/yarp/node.rb#8620 + def ConstantPathWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new ConstantReadNode node + # + # source://yarp//lib/yarp/node.rb#8625 + def ConstantReadNode(location = T.unsafe(nil)); end + + # Create a new ConstantTargetNode node + # + # source://yarp//lib/yarp/node.rb#8630 + def ConstantTargetNode(location = T.unsafe(nil)); end + + # Create a new ConstantWriteNode node + # + # source://yarp//lib/yarp/node.rb#8635 + def ConstantWriteNode(name_loc, value, operator_loc, location = T.unsafe(nil)); end + + # Create a new DefNode node + # + # source://yarp//lib/yarp/node.rb#8640 + def DefNode(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new DefinedNode node + # + # source://yarp//lib/yarp/node.rb#8645 + def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = T.unsafe(nil)); end + + # Create a new ElseNode node + # + # source://yarp//lib/yarp/node.rb#8650 + def ElseNode(else_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new EmbeddedStatementsNode node + # + # source://yarp//lib/yarp/node.rb#8655 + def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = T.unsafe(nil)); end + + # Create a new EmbeddedVariableNode node + # + # source://yarp//lib/yarp/node.rb#8660 + def EmbeddedVariableNode(operator_loc, variable, location = T.unsafe(nil)); end + + # Create a new EnsureNode node + # + # source://yarp//lib/yarp/node.rb#8665 + def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new FalseNode node + # + # source://yarp//lib/yarp/node.rb#8670 + def FalseNode(location = T.unsafe(nil)); end + + # Create a new FindPatternNode node + # + # source://yarp//lib/yarp/node.rb#8675 + def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new FlipFlopNode node + # + # source://yarp//lib/yarp/node.rb#8680 + def FlipFlopNode(left, right, operator_loc, flags, location = T.unsafe(nil)); end + + # Create a new FloatNode node + # + # source://yarp//lib/yarp/node.rb#8685 + def FloatNode(location = T.unsafe(nil)); end + + # Create a new ForNode node + # + # source://yarp//lib/yarp/node.rb#8690 + def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new ForwardingArgumentsNode node + # + # source://yarp//lib/yarp/node.rb#8695 + def ForwardingArgumentsNode(location = T.unsafe(nil)); end + + # Create a new ForwardingParameterNode node + # + # source://yarp//lib/yarp/node.rb#8700 + def ForwardingParameterNode(location = T.unsafe(nil)); end + + # Create a new ForwardingSuperNode node + # + # source://yarp//lib/yarp/node.rb#8705 + def ForwardingSuperNode(block, location = T.unsafe(nil)); end + + # Create a new GlobalVariableAndWriteNode node + # + # source://yarp//lib/yarp/node.rb#8710 + def GlobalVariableAndWriteNode(name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new GlobalVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/node.rb#8715 + def GlobalVariableOperatorWriteNode(name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end + + # Create a new GlobalVariableOrWriteNode node + # + # source://yarp//lib/yarp/node.rb#8720 + def GlobalVariableOrWriteNode(name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new GlobalVariableReadNode node + # + # source://yarp//lib/yarp/node.rb#8725 + def GlobalVariableReadNode(location = T.unsafe(nil)); end + + # Create a new GlobalVariableTargetNode node + # + # source://yarp//lib/yarp/node.rb#8730 + def GlobalVariableTargetNode(location = T.unsafe(nil)); end + + # Create a new GlobalVariableWriteNode node + # + # source://yarp//lib/yarp/node.rb#8735 + def GlobalVariableWriteNode(name_loc, value, operator_loc, location = T.unsafe(nil)); end + + # Create a new HashNode node + # + # source://yarp//lib/yarp/node.rb#8740 + def HashNode(opening_loc, elements, closing_loc, location = T.unsafe(nil)); end + + # Create a new HashPatternNode node + # + # source://yarp//lib/yarp/node.rb#8745 + def HashPatternNode(constant, assocs, kwrest, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new IfNode node + # + # source://yarp//lib/yarp/node.rb#8750 + def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new ImaginaryNode node + # + # source://yarp//lib/yarp/node.rb#8755 + def ImaginaryNode(numeric, location = T.unsafe(nil)); end + + # Create a new InNode node + # + # source://yarp//lib/yarp/node.rb#8760 + def InNode(pattern, statements, in_loc, then_loc, location = T.unsafe(nil)); end + + # Create a new InstanceVariableAndWriteNode node + # + # source://yarp//lib/yarp/node.rb#8765 + def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new InstanceVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/node.rb#8770 + def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end + + # Create a new InstanceVariableOrWriteNode node + # + # source://yarp//lib/yarp/node.rb#8775 + def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new InstanceVariableReadNode node + # + # source://yarp//lib/yarp/node.rb#8780 + def InstanceVariableReadNode(name, location = T.unsafe(nil)); end + + # Create a new InstanceVariableTargetNode node + # + # source://yarp//lib/yarp/node.rb#8785 + def InstanceVariableTargetNode(name, location = T.unsafe(nil)); end + + # Create a new InstanceVariableWriteNode node + # + # source://yarp//lib/yarp/node.rb#8790 + def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end + + # Create a new IntegerNode node + # + # source://yarp//lib/yarp/node.rb#8795 + def IntegerNode(location = T.unsafe(nil)); end + + # Create a new InterpolatedRegularExpressionNode node + # + # source://yarp//lib/yarp/node.rb#8800 + def InterpolatedRegularExpressionNode(opening_loc, parts, closing_loc, flags, location = T.unsafe(nil)); end + + # Create a new InterpolatedStringNode node + # + # source://yarp//lib/yarp/node.rb#8805 + def InterpolatedStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end + + # Create a new InterpolatedSymbolNode node + # + # source://yarp//lib/yarp/node.rb#8810 + def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end + + # Create a new InterpolatedXStringNode node + # + # source://yarp//lib/yarp/node.rb#8815 + def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end + + # Create a new KeywordHashNode node + # + # source://yarp//lib/yarp/node.rb#8820 + def KeywordHashNode(elements, location = T.unsafe(nil)); end + + # Create a new KeywordParameterNode node + # + # source://yarp//lib/yarp/node.rb#8825 + def KeywordParameterNode(name_loc, value, location = T.unsafe(nil)); end + + # Create a new KeywordRestParameterNode node + # + # source://yarp//lib/yarp/node.rb#8830 + def KeywordRestParameterNode(operator_loc, name_loc, location = T.unsafe(nil)); end + + # Create a new LambdaNode node + # + # source://yarp//lib/yarp/node.rb#8835 + def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location = T.unsafe(nil)); end + + # Create a new LocalVariableAndWriteNode node + # + # source://yarp//lib/yarp/node.rb#8840 + def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end + + # Create a new LocalVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/node.rb#8845 + def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = T.unsafe(nil)); end + + # Create a new LocalVariableOrWriteNode node + # + # source://yarp//lib/yarp/node.rb#8850 + def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end + + # Create a new LocalVariableReadNode node + # + # source://yarp//lib/yarp/node.rb#8855 + def LocalVariableReadNode(name, depth, location = T.unsafe(nil)); end + + # Create a new LocalVariableTargetNode node + # + # source://yarp//lib/yarp/node.rb#8860 + def LocalVariableTargetNode(name, depth, location = T.unsafe(nil)); end + + # Create a new LocalVariableWriteNode node + # + # source://yarp//lib/yarp/node.rb#8865 + def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = T.unsafe(nil)); end + + # Create a new Location object + # + # source://yarp//lib/yarp/node.rb#8435 + def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end + + # Create a new MatchPredicateNode node + # + # source://yarp//lib/yarp/node.rb#8870 + def MatchPredicateNode(value, pattern, operator_loc, location = T.unsafe(nil)); end + + # Create a new MatchRequiredNode node + # + # source://yarp//lib/yarp/node.rb#8875 + def MatchRequiredNode(value, pattern, operator_loc, location = T.unsafe(nil)); end + + # Create a new MissingNode node + # + # source://yarp//lib/yarp/node.rb#8880 + def MissingNode(location = T.unsafe(nil)); end + + # Create a new ModuleNode node + # + # source://yarp//lib/yarp/node.rb#8885 + def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location = T.unsafe(nil)); end + + # Create a new MultiWriteNode node + # + # source://yarp//lib/yarp/node.rb#8890 + def MultiWriteNode(targets, operator_loc, value, lparen_loc, rparen_loc, location = T.unsafe(nil)); end + + # Create a new NextNode node + # + # source://yarp//lib/yarp/node.rb#8895 + def NextNode(arguments, keyword_loc, location = T.unsafe(nil)); end + + # Create a new NilNode node + # + # source://yarp//lib/yarp/node.rb#8900 + def NilNode(location = T.unsafe(nil)); end + + # Create a new NoKeywordsParameterNode node + # + # source://yarp//lib/yarp/node.rb#8905 + def NoKeywordsParameterNode(operator_loc, keyword_loc, location = T.unsafe(nil)); end + + # Create a new NumberedReferenceReadNode node + # + # source://yarp//lib/yarp/node.rb#8910 + def NumberedReferenceReadNode(number, location = T.unsafe(nil)); end + + # Create a new OptionalParameterNode node + # + # source://yarp//lib/yarp/node.rb#8915 + def OptionalParameterNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end + + # Create a new OrNode node + # + # source://yarp//lib/yarp/node.rb#8920 + def OrNode(left, right, operator_loc, location = T.unsafe(nil)); end + + # Create a new ParametersNode node + # + # source://yarp//lib/yarp/node.rb#8925 + def ParametersNode(requireds, optionals, posts, rest, keywords, keyword_rest, block, location = T.unsafe(nil)); end + + # Create a new ParenthesesNode node + # + # source://yarp//lib/yarp/node.rb#8930 + def ParenthesesNode(body, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new PinnedExpressionNode node + # + # source://yarp//lib/yarp/node.rb#8935 + def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = T.unsafe(nil)); end + + # Create a new PinnedVariableNode node + # + # source://yarp//lib/yarp/node.rb#8940 + def PinnedVariableNode(variable, operator_loc, location = T.unsafe(nil)); end + + # Create a new PostExecutionNode node + # + # source://yarp//lib/yarp/node.rb#8945 + def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new PreExecutionNode node + # + # source://yarp//lib/yarp/node.rb#8950 + def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new ProgramNode node + # + # source://yarp//lib/yarp/node.rb#8955 + def ProgramNode(locals, statements, location = T.unsafe(nil)); end + + # Create a new RangeNode node + # + # source://yarp//lib/yarp/node.rb#8960 + def RangeNode(left, right, operator_loc, flags, location = T.unsafe(nil)); end + + # Create a new RationalNode node + # + # source://yarp//lib/yarp/node.rb#8965 + def RationalNode(numeric, location = T.unsafe(nil)); end + + # Create a new RedoNode node + # + # source://yarp//lib/yarp/node.rb#8970 + def RedoNode(location = T.unsafe(nil)); end + + # Create a new RegularExpressionNode node + # + # source://yarp//lib/yarp/node.rb#8975 + def RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location = T.unsafe(nil)); end + + # Create a new RequiredDestructuredParameterNode node + # + # source://yarp//lib/yarp/node.rb#8980 + def RequiredDestructuredParameterNode(parameters, opening_loc, closing_loc, location = T.unsafe(nil)); end + + # Create a new RequiredParameterNode node + # + # source://yarp//lib/yarp/node.rb#8985 + def RequiredParameterNode(name, location = T.unsafe(nil)); end + + # Create a new RescueModifierNode node + # + # source://yarp//lib/yarp/node.rb#8990 + def RescueModifierNode(expression, keyword_loc, rescue_expression, location = T.unsafe(nil)); end + + # Create a new RescueNode node + # + # source://yarp//lib/yarp/node.rb#8995 + def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = T.unsafe(nil)); end + + # Create a new RestParameterNode node + # + # source://yarp//lib/yarp/node.rb#9000 + def RestParameterNode(operator_loc, name_loc, location = T.unsafe(nil)); end + + # Create a new RetryNode node + # + # source://yarp//lib/yarp/node.rb#9005 + def RetryNode(location = T.unsafe(nil)); end + + # Create a new ReturnNode node + # + # source://yarp//lib/yarp/node.rb#9010 + def ReturnNode(keyword_loc, arguments, location = T.unsafe(nil)); end + + # Create a new SelfNode node + # + # source://yarp//lib/yarp/node.rb#9015 + def SelfNode(location = T.unsafe(nil)); end + + # Create a new SingletonClassNode node + # + # source://yarp//lib/yarp/node.rb#9020 + def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new SourceEncodingNode node + # + # source://yarp//lib/yarp/node.rb#9025 + def SourceEncodingNode(location = T.unsafe(nil)); end + + # Create a new SourceFileNode node + # + # source://yarp//lib/yarp/node.rb#9030 + def SourceFileNode(filepath, location = T.unsafe(nil)); end + + # Create a new SourceLineNode node + # + # source://yarp//lib/yarp/node.rb#9035 + def SourceLineNode(location = T.unsafe(nil)); end + + # Create a new SplatNode node + # + # source://yarp//lib/yarp/node.rb#9040 + def SplatNode(operator_loc, expression, location = T.unsafe(nil)); end + + # Create a new StatementsNode node + # + # source://yarp//lib/yarp/node.rb#9045 + def StatementsNode(body, location = T.unsafe(nil)); end + + # Create a new StringConcatNode node + # + # source://yarp//lib/yarp/node.rb#9050 + def StringConcatNode(left, right, location = T.unsafe(nil)); end + + # Create a new StringNode node + # + # source://yarp//lib/yarp/node.rb#9055 + def StringNode(opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end + + # Create a new SuperNode node + # + # source://yarp//lib/yarp/node.rb#9060 + def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = T.unsafe(nil)); end + + # Create a new SymbolNode node + # + # source://yarp//lib/yarp/node.rb#9065 + def SymbolNode(opening_loc, value_loc, closing_loc, unescaped, location = T.unsafe(nil)); end + + # Create a new TrueNode node + # + # source://yarp//lib/yarp/node.rb#9070 + def TrueNode(location = T.unsafe(nil)); end + + # Create a new UndefNode node + # + # source://yarp//lib/yarp/node.rb#9075 + def UndefNode(names, keyword_loc, location = T.unsafe(nil)); end + + # Create a new UnlessNode node + # + # source://yarp//lib/yarp/node.rb#9080 + def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end + + # Create a new UntilNode node + # + # source://yarp//lib/yarp/node.rb#9085 + def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location = T.unsafe(nil)); end + + # Create a new WhenNode node + # + # source://yarp//lib/yarp/node.rb#9090 + def WhenNode(keyword_loc, conditions, statements, location = T.unsafe(nil)); end + + # Create a new WhileNode node + # + # source://yarp//lib/yarp/node.rb#9095 + def WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location = T.unsafe(nil)); end + + # Create a new XStringNode node + # + # source://yarp//lib/yarp/node.rb#9100 + def XStringNode(opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end + + # Create a new YieldNode node + # + # source://yarp//lib/yarp/node.rb#9105 + def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = T.unsafe(nil)); end +end + +# This module is used for testing and debugging and is not meant to be used by +# consumers of this library. +# +# source://yarp//lib/yarp.rb#367 +module YARP::Debug + class << self + # For the given source, compiles with CRuby and returns a list of all of the + # sets of local variables that were encountered. + # + # source://yarp//lib/yarp.rb#408 + def cruby_locals(source); end + + def memsize(_arg0); end + def named_captures(_arg0); end + + # source://yarp//lib/yarp.rb#514 + def newlines(source); end + + # source://yarp//lib/yarp.rb#518 + def parse_serialize_file(filepath); end + + def parse_serialize_file_metadata(_arg0, _arg1); end + def profile_file(_arg0); end + def unescape_all(_arg0); end + def unescape_minimal(_arg0); end + def unescape_none(_arg0); end + + # For the given source, parses with YARP and returns a list of all of the + # sets of local variables that were encountered. + # + # source://yarp//lib/yarp.rb#447 + def yarp_locals(source); end + end +end + +# source://yarp//lib/yarp.rb#368 +class YARP::Debug::ISeq + # @return [ISeq] a new instance of ISeq + # + # source://yarp//lib/yarp.rb#371 + def initialize(parts); end + + # source://yarp//lib/yarp.rb#387 + def each_child; end + + # source://yarp//lib/yarp.rb#383 + def instructions; end + + # source://yarp//lib/yarp.rb#379 + def local_table; end + + # Returns the value of attribute parts. + # + # source://yarp//lib/yarp.rb#369 + def parts; end + + # source://yarp//lib/yarp.rb#375 + def type; end +end + +# Represents a method definition. +# +# def method +# end +# ^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2396 +class YARP::DefNode < ::YARP::Node + # def initialize: (name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void + # + # @return [DefNode] a new instance of DefNode + # + # source://yarp//lib/yarp/node.rb#2431 + def initialize(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2447 + def accept(visitor); end + + # attr_reader body: Node? + # + # source://yarp//lib/yarp/node.rb#2407 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2452 + def child_nodes; end + + # def copy: (**params) -> DefNode + # + # source://yarp//lib/yarp/node.rb#2457 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2452 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2478 + def deconstruct_keys(keys); end + + # def def_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#2488 + def def_keyword; end + + # attr_reader def_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#2413 + def def_keyword_loc; end + + # def end_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#2513 + def end_keyword; end + + # attr_reader end_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2428 + def end_keyword_loc; end + + # def equal: () -> String? + # + # source://yarp//lib/yarp/node.rb#2508 + def equal; end + + # attr_reader equal_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2425 + def equal_loc; end + + # attr_reader locals: Array[Symbol] + # + # source://yarp//lib/yarp/node.rb#2410 + def locals; end + + # def lparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#2498 + def lparen; end + + # attr_reader lparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2419 + def lparen_loc; end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#2483 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#2398 + def name_loc; end + + # def operator: () -> String? + # + # source://yarp//lib/yarp/node.rb#2493 + def operator; end + + # attr_reader operator_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2416 + def operator_loc; end + + # attr_reader parameters: ParametersNode? + # + # source://yarp//lib/yarp/node.rb#2404 + def parameters; end + + # attr_reader receiver: Node? + # + # source://yarp//lib/yarp/node.rb#2401 + def receiver; end + + # def rparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#2503 + def rparen; end + + # attr_reader rparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2422 + def rparen_loc; end +end + +# Represents the use of the `defined?` keyword. +# +# defined?(a) +# ^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2522 +class YARP::DefinedNode < ::YARP::Node + # def initialize: (lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location) -> void + # + # @return [DefinedNode] a new instance of DefinedNode + # + # source://yarp//lib/yarp/node.rb#2536 + def initialize(lparen_loc, value, rparen_loc, keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2545 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2550 + def child_nodes; end + + # def copy: (**params) -> DefinedNode + # + # source://yarp//lib/yarp/node.rb#2555 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2550 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2569 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#2584 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#2533 + def keyword_loc; end + + # def lparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#2574 + def lparen; end + + # attr_reader lparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2524 + def lparen_loc; end + + # def rparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#2579 + def rparen; end + + # attr_reader rparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2530 + def rparen_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#2527 + def value; end +end + +# source://yarp//lib/yarp/desugar_visitor.rb#4 +class YARP::DesugarVisitor < ::YARP::MutationVisitor + # @@foo &&= bar + # + # becomes + # + # @@foo && @@foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#10 + def visit_class_variable_and_write_node(node); end + + # @@foo += bar + # + # becomes + # + # @@foo = @@foo + bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#28 + def visit_class_variable_operator_write_node(node); end + + # @@foo ||= bar + # + # becomes + # + # defined?(@@foo) ? @@foo : @@foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#19 + def visit_class_variable_or_write_node(node); end + + # Foo &&= bar + # + # becomes + # + # Foo && Foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#37 + def visit_constant_and_write_node(node); end + + # Foo += bar + # + # becomes + # + # Foo = Foo + bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#55 + def visit_constant_operator_write_node(node); end + + # Foo ||= bar + # + # becomes + # + # defined?(Foo) ? Foo : Foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#46 + def visit_constant_or_write_node(node); end + + # $foo &&= bar + # + # becomes + # + # $foo && $foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#64 + def visit_global_variable_and_write_node(node); end + + # $foo += bar + # + # becomes + # + # $foo = $foo + bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#82 + def visit_global_variable_operator_write_node(node); end + + # $foo ||= bar + # + # becomes + # + # defined?($foo) ? $foo : $foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#73 + def visit_global_variable_or_write_node(node); end + + # becomes + # + # source://yarp//lib/yarp/desugar_visitor.rb#91 + def visit_instance_variable_and_write_node(node); end + + # becomes + # + # source://yarp//lib/yarp/desugar_visitor.rb#109 + def visit_instance_variable_operator_write_node(node); end + + # becomes + # + # source://yarp//lib/yarp/desugar_visitor.rb#100 + def visit_instance_variable_or_write_node(node); end + + # foo &&= bar + # + # becomes + # + # foo && foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#118 + def visit_local_variable_and_write_node(node); end + + # foo += bar + # + # becomes + # + # foo = foo + bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#136 + def visit_local_variable_operator_write_node(node); end + + # foo ||= bar + # + # becomes + # + # foo || foo = bar + # + # source://yarp//lib/yarp/desugar_visitor.rb#127 + def visit_local_variable_or_write_node(node); end + + private + + # Desugar `x &&= y` to `x && x = y` + # + # source://yarp//lib/yarp/desugar_visitor.rb#143 + def desugar_and_write_node(node, read_class, write_class, arguments: T.unsafe(nil)); end + + # Desugar `x += y` to `x = x + y` + # + # source://yarp//lib/yarp/desugar_visitor.rb#153 + def desugar_operator_write_node(node, read_class, write_class, arguments: T.unsafe(nil)); end + + # Desugar `x ||= y` to `defined?(x) ? x : x = y` + # + # source://yarp//lib/yarp/desugar_visitor.rb#185 + def desugar_or_write_defined_node(node, read_class, write_class, arguments: T.unsafe(nil)); end + + # Desugar `x ||= y` to `x || x = y` + # + # source://yarp//lib/yarp/desugar_visitor.rb#175 + def desugar_or_write_node(node, read_class, write_class, arguments: T.unsafe(nil)); end +end + +# Represents an `else` clause in a `case`, `if`, or `unless` statement. +# +# if a then b else c end +# ^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2593 +class YARP::ElseNode < ::YARP::Node + # def initialize: (else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location) -> void + # + # @return [ElseNode] a new instance of ElseNode + # + # source://yarp//lib/yarp/node.rb#2604 + def initialize(else_keyword_loc, statements, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2612 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2617 + def child_nodes; end + + # def copy: (**params) -> ElseNode + # + # source://yarp//lib/yarp/node.rb#2622 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2617 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2635 + def deconstruct_keys(keys); end + + # def else_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#2640 + def else_keyword; end + + # attr_reader else_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#2595 + def else_keyword_loc; end + + # def end_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#2645 + def end_keyword; end + + # attr_reader end_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2601 + def end_keyword_loc; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#2598 + def statements; end +end + +# Represents an interpolated set of statements. +# +# "foo #{bar}" +# ^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2654 +class YARP::EmbeddedStatementsNode < ::YARP::Node + # def initialize: (opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location) -> void + # + # @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode + # + # source://yarp//lib/yarp/node.rb#2665 + def initialize(opening_loc, statements, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2673 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2678 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#2706 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#2662 + def closing_loc; end + + # def copy: (**params) -> EmbeddedStatementsNode + # + # source://yarp//lib/yarp/node.rb#2683 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2678 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2696 + def deconstruct_keys(keys); end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#2701 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#2656 + def opening_loc; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#2659 + def statements; end +end + +# Represents an interpolated variable. +# +# "foo #@bar" +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#2715 +class YARP::EmbeddedVariableNode < ::YARP::Node + # def initialize: (operator_loc: Location, variable: Node, location: Location) -> void + # + # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode + # + # source://yarp//lib/yarp/node.rb#2723 + def initialize(operator_loc, variable, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2730 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2735 + def child_nodes; end + + # def copy: (**params) -> EmbeddedVariableNode + # + # source://yarp//lib/yarp/node.rb#2740 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2735 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2752 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#2757 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#2717 + def operator_loc; end + + # attr_reader variable: Node + # + # source://yarp//lib/yarp/node.rb#2720 + def variable; end +end + +# Represents an `ensure` clause in a `begin` statement. +# +# begin +# foo +# ensure +# ^^^^^^ +# bar +# end +# +# source://yarp//lib/yarp/node.rb#2770 +class YARP::EnsureNode < ::YARP::Node + # def initialize: (ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location) -> void + # + # @return [EnsureNode] a new instance of EnsureNode + # + # source://yarp//lib/yarp/node.rb#2781 + def initialize(ensure_keyword_loc, statements, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2789 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2794 + def child_nodes; end + + # def copy: (**params) -> EnsureNode + # + # source://yarp//lib/yarp/node.rb#2799 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2794 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2812 + def deconstruct_keys(keys); end + + # def end_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#2822 + def end_keyword; end + + # attr_reader end_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#2778 + def end_keyword_loc; end + + # def ensure_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#2817 + def ensure_keyword; end + + # attr_reader ensure_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#2772 + def ensure_keyword_loc; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#2775 + def statements; end +end + +# Represents the use of the literal `false` keyword. +# +# false +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#2831 +class YARP::FalseNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [FalseNode] a new instance of FalseNode + # + # source://yarp//lib/yarp/node.rb#2833 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2838 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2843 + def child_nodes; end + + # def copy: (**params) -> FalseNode + # + # source://yarp//lib/yarp/node.rb#2848 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2843 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2858 + def deconstruct_keys(keys); end +end + +# Represents a find pattern in pattern matching. +# +# foo in *bar, baz, *qux +# ^^^^^^^^^^^^^^^^^^^^^^ +# +# foo in [*bar, baz, *qux] +# ^^^^^^^^^^^^^^^^^^^^^^^^ +# +# foo in Foo(*bar, baz, *qux) +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2873 +class YARP::FindPatternNode < ::YARP::Node + # def initialize: (constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location) -> void + # + # @return [FindPatternNode] a new instance of FindPatternNode + # + # source://yarp//lib/yarp/node.rb#2893 + def initialize(constant, left, requireds, right, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2904 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2909 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#2940 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2890 + def closing_loc; end + + # attr_reader constant: Node? + # + # source://yarp//lib/yarp/node.rb#2875 + def constant; end + + # def copy: (**params) -> FindPatternNode + # + # source://yarp//lib/yarp/node.rb#2914 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2909 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2930 + def deconstruct_keys(keys); end + + # attr_reader left: Node + # + # source://yarp//lib/yarp/node.rb#2878 + def left; end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#2935 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#2887 + def opening_loc; end + + # attr_reader requireds: Array[Node] + # + # source://yarp//lib/yarp/node.rb#2881 + def requireds; end + + # attr_reader right: Node + # + # source://yarp//lib/yarp/node.rb#2884 + def right; end +end + +# Represents the use of the `..` or `...` operators to create flip flops. +# +# baz if foo .. bar +# ^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#2949 +class YARP::FlipFlopNode < ::YARP::Node + # def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void + # + # @return [FlipFlopNode] a new instance of FlipFlopNode + # + # source://yarp//lib/yarp/node.rb#2963 + def initialize(left, right, operator_loc, flags, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#2972 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2977 + def child_nodes; end + + # def copy: (**params) -> FlipFlopNode + # + # source://yarp//lib/yarp/node.rb#2982 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#2977 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#2996 + def deconstruct_keys(keys); end + + # def exclude_end?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#3006 + def exclude_end?; end + + # attr_reader flags: Integer + # + # source://yarp//lib/yarp/node.rb#2960 + def flags; end + + # attr_reader left: Node? + # + # source://yarp//lib/yarp/node.rb#2951 + def left; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#3001 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#2957 + def operator_loc; end + + # attr_reader right: Node? + # + # source://yarp//lib/yarp/node.rb#2954 + def right; end +end + +# Represents a floating point number literal. +# +# 1.0 +# ^^^ +# +# source://yarp//lib/yarp.rb#336 +class YARP::FloatNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [FloatNode] a new instance of FloatNode + # + # source://yarp//lib/yarp/node.rb#3017 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3022 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3027 + def child_nodes; end + + # def copy: (**params) -> FloatNode + # + # source://yarp//lib/yarp/node.rb#3032 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3027 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3042 + def deconstruct_keys(keys); end + + # source://yarp//lib/yarp.rb#337 + def value; end +end + +# Represents the use of the `for` keyword. +# +# for i in a end +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3051 +class YARP::ForNode < ::YARP::Node + # def initialize: (index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> void + # + # @return [ForNode] a new instance of ForNode + # + # source://yarp//lib/yarp/node.rb#3074 + def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3086 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3091 + def child_nodes; end + + # attr_reader collection: Node + # + # source://yarp//lib/yarp/node.rb#3056 + def collection; end + + # def copy: (**params) -> ForNode + # + # source://yarp//lib/yarp/node.rb#3096 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3091 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3113 + def deconstruct_keys(keys); end + + # def do_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#3128 + def do_keyword; end + + # attr_reader do_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#3068 + def do_keyword_loc; end + + # def end_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#3133 + def end_keyword; end + + # attr_reader end_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#3071 + def end_keyword_loc; end + + # def for_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#3118 + def for_keyword; end + + # attr_reader for_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#3062 + def for_keyword_loc; end + + # def in_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#3123 + def in_keyword; end + + # attr_reader in_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#3065 + def in_keyword_loc; end + + # attr_reader index: Node + # + # source://yarp//lib/yarp/node.rb#3053 + def index; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#3059 + def statements; end +end + +# Represents forwarding all arguments to this method to another method. +# +# def foo(...) +# bar(...) +# ^^^^^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#3144 +class YARP::ForwardingArgumentsNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode + # + # source://yarp//lib/yarp/node.rb#3146 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3151 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3156 + def child_nodes; end + + # def copy: (**params) -> ForwardingArgumentsNode + # + # source://yarp//lib/yarp/node.rb#3161 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3156 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3171 + def deconstruct_keys(keys); end +end + +# Represents the use of the forwarding parameter in a method, block, or lambda declaration. +# +# def foo(...) +# ^^^ +# end +# +# source://yarp//lib/yarp/node.rb#3181 +class YARP::ForwardingParameterNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode + # + # source://yarp//lib/yarp/node.rb#3183 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3188 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3193 + def child_nodes; end + + # def copy: (**params) -> ForwardingParameterNode + # + # source://yarp//lib/yarp/node.rb#3198 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3193 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3208 + def deconstruct_keys(keys); end +end + +# Represents the use of the `super` keyword without parentheses or arguments. +# +# super +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#3217 +class YARP::ForwardingSuperNode < ::YARP::Node + # def initialize: (block: BlockNode?, location: Location) -> void + # + # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode + # + # source://yarp//lib/yarp/node.rb#3222 + def initialize(block, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3228 + def accept(visitor); end + + # attr_reader block: BlockNode? + # + # source://yarp//lib/yarp/node.rb#3219 + def block; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3233 + def child_nodes; end + + # def copy: (**params) -> ForwardingSuperNode + # + # source://yarp//lib/yarp/node.rb#3238 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3233 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3249 + def deconstruct_keys(keys); end +end + +# Represents the use of the `&&=` operator for assignment to a global variable. +# +# $target &&= value +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3258 +class YARP::GlobalVariableAndWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#3269 + def initialize(name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3277 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3282 + def child_nodes; end + + # def copy: (**params) -> GlobalVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#3287 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3282 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3300 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#3305 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#3260 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#3310 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#3263 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#3266 + def value; end +end + +# Represents assigning to a global variable using an operator that isn't `=`. +# +# $target += value +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3319 +class YARP::GlobalVariableOperatorWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void + # + # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#3333 + def initialize(name_loc, operator_loc, value, operator, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3342 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3347 + def child_nodes; end + + # def copy: (**params) -> GlobalVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#3352 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3347 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3366 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#3371 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#3321 + def name_loc; end + + # attr_reader operator: Symbol + # + # source://yarp//lib/yarp/node.rb#3330 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#3324 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#3327 + def value; end +end + +# Represents the use of the `||=` operator for assignment to a global variable. +# +# $target ||= value +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3380 +class YARP::GlobalVariableOrWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#3391 + def initialize(name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3399 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3404 + def child_nodes; end + + # def copy: (**params) -> GlobalVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#3409 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3404 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3422 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#3427 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#3382 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#3432 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#3385 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#3388 + def value; end +end + +# Represents referencing a global variable. +# +# $foo +# ^^^^ +# +# source://yarp//lib/yarp/node.rb#3441 +class YARP::GlobalVariableReadNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode + # + # source://yarp//lib/yarp/node.rb#3443 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3448 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3453 + def child_nodes; end + + # def copy: (**params) -> GlobalVariableReadNode + # + # source://yarp//lib/yarp/node.rb#3458 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3453 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3468 + def deconstruct_keys(keys); end +end + +# Represents writing to a global variable in a context that doesn't have an explicit value. +# +# $foo, $bar = baz +# ^^^^ ^^^^ +# +# source://yarp//lib/yarp/node.rb#3477 +class YARP::GlobalVariableTargetNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#3479 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3484 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3489 + def child_nodes; end + + # def copy: (**params) -> GlobalVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#3494 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3489 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3504 + def deconstruct_keys(keys); end +end + +# Represents writing to a global variable. +# +# $foo = 1 +# ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3513 +class YARP::GlobalVariableWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void + # + # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#3524 + def initialize(name_loc, value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3532 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3537 + def child_nodes; end + + # def copy: (**params) -> GlobalVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#3542 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3537 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3555 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#3560 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#3515 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#3565 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#3521 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#3518 + def value; end +end + +# Represents a hash literal. +# +# { a => b } +# ^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3574 +class YARP::HashNode < ::YARP::Node + # def initialize: (opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location) -> void + # + # @return [HashNode] a new instance of HashNode + # + # source://yarp//lib/yarp/node.rb#3585 + def initialize(opening_loc, elements, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3593 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3598 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#3626 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#3582 + def closing_loc; end + + # def copy: (**params) -> HashNode + # + # source://yarp//lib/yarp/node.rb#3603 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3598 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3616 + def deconstruct_keys(keys); end + + # attr_reader elements: Array[Node] + # + # source://yarp//lib/yarp/node.rb#3579 + def elements; end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#3621 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#3576 + def opening_loc; end +end + +# Represents a hash pattern in pattern matching. +# +# foo => { a: 1, b: 2 } +# ^^^^^^^^^^^^^^ +# +# foo => { a: 1, b: 2, **c } +# ^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3638 +class YARP::HashPatternNode < ::YARP::Node + # def initialize: (constant: Node?, assocs: Array[Node], kwrest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void + # + # @return [HashPatternNode] a new instance of HashPatternNode + # + # source://yarp//lib/yarp/node.rb#3655 + def initialize(constant, assocs, kwrest, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3665 + def accept(visitor); end + + # attr_reader assocs: Array[Node] + # + # source://yarp//lib/yarp/node.rb#3643 + def assocs; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3670 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#3700 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#3652 + def closing_loc; end + + # attr_reader constant: Node? + # + # source://yarp//lib/yarp/node.rb#3640 + def constant; end + + # def copy: (**params) -> HashPatternNode + # + # source://yarp//lib/yarp/node.rb#3675 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3670 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3690 + def deconstruct_keys(keys); end + + # attr_reader kwrest: Node? + # + # source://yarp//lib/yarp/node.rb#3646 + def kwrest; end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#3695 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#3649 + def opening_loc; end +end + +# Represents the use of the `if` keyword, either in the block form or the modifier form. +# +# bar if foo +# ^^^^^^^^^^ +# +# if foo then bar end +# ^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3712 +class YARP::IfNode < ::YARP::Node + # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void + # + # @return [IfNode] a new instance of IfNode + # + # source://yarp//lib/yarp/node.rb#3729 + def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3739 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3748 + def child_nodes; end + + # attr_reader consequent: Node? + # + # source://yarp//lib/yarp/node.rb#3723 + def consequent; end + + # def copy: (**params) -> IfNode + # + # source://yarp//lib/yarp/node.rb#3753 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3748 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3768 + def deconstruct_keys(keys); end + + # def end_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#3778 + def end_keyword; end + + # attr_reader end_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#3726 + def end_keyword_loc; end + + # def if_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#3773 + def if_keyword; end + + # attr_reader if_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#3714 + def if_keyword_loc; end + + # attr_reader predicate: Node + # + # source://yarp//lib/yarp/node.rb#3717 + def predicate; end + + # source://yarp//lib/yarp/node.rb#3743 + def set_newline_flag(newline_marked); end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#3720 + def statements; end +end + +# Represents an imaginary number literal. +# +# 1.0i +# ^^^^ +# +# source://yarp//lib/yarp.rb#342 +class YARP::ImaginaryNode < ::YARP::Node + # def initialize: (numeric: Node, location: Location) -> void + # + # @return [ImaginaryNode] a new instance of ImaginaryNode + # + # source://yarp//lib/yarp/node.rb#3792 + def initialize(numeric, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3798 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3803 + def child_nodes; end + + # def copy: (**params) -> ImaginaryNode + # + # source://yarp//lib/yarp/node.rb#3808 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3803 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3819 + def deconstruct_keys(keys); end + + # attr_reader numeric: Node + # + # source://yarp//lib/yarp/node.rb#3789 + def numeric; end + + # source://yarp//lib/yarp.rb#343 + def value; end +end + +# Represents the use of the `in` keyword in a case statement. +# +# case a; in b then c end +# ^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3828 +class YARP::InNode < ::YARP::Node + # def initialize: (pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location) -> void + # + # @return [InNode] a new instance of InNode + # + # source://yarp//lib/yarp/node.rb#3842 + def initialize(pattern, statements, in_loc, then_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3851 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3856 + def child_nodes; end + + # def copy: (**params) -> InNode + # + # source://yarp//lib/yarp/node.rb#3861 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3856 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3875 + def deconstruct_keys(keys); end + + # def in: () -> String + # + # source://yarp//lib/yarp/node.rb#3880 + def in; end + + # attr_reader in_loc: Location + # + # source://yarp//lib/yarp/node.rb#3836 + def in_loc; end + + # attr_reader pattern: Node + # + # source://yarp//lib/yarp/node.rb#3830 + def pattern; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#3833 + def statements; end + + # def then: () -> String? + # + # source://yarp//lib/yarp/node.rb#3885 + def then; end + + # attr_reader then_loc: Location? + # + # source://yarp//lib/yarp/node.rb#3839 + def then_loc; end +end + +# Represents the use of the `&&=` operator for assignment to an instance variable. +# +# @target &&= value +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3894 +class YARP::InstanceVariableAndWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#3908 + def initialize(name, name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3917 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3922 + def child_nodes; end + + # def copy: (**params) -> InstanceVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#3927 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3922 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#3941 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#3896 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#3899 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#3946 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#3902 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#3905 + def value; end +end + +# Represents assigning to an instance variable using an operator that isn't `=`. +# +# @target += value +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#3955 +class YARP::InstanceVariableOperatorWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void + # + # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#3972 + def initialize(name, name_loc, operator_loc, value, operator, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#3982 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3987 + def child_nodes; end + + # def copy: (**params) -> InstanceVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#3992 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#3987 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4007 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#3957 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#3960 + def name_loc; end + + # attr_reader operator: Symbol + # + # source://yarp//lib/yarp/node.rb#3969 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#3963 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#3966 + def value; end +end + +# Represents the use of the `||=` operator for assignment to an instance variable. +# +# @target ||= value +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4016 +class YARP::InstanceVariableOrWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#4030 + def initialize(name, name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4039 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4044 + def child_nodes; end + + # def copy: (**params) -> InstanceVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#4049 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4044 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4063 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#4018 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#4021 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#4068 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#4024 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#4027 + def value; end +end + +# Represents referencing an instance variable. +# +# @foo +# ^^^^ +# +# source://yarp//lib/yarp/node.rb#4077 +class YARP::InstanceVariableReadNode < ::YARP::Node + # def initialize: (name: Symbol, location: Location) -> void + # + # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode + # + # source://yarp//lib/yarp/node.rb#4082 + def initialize(name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4088 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4093 + def child_nodes; end + + # def copy: (**params) -> InstanceVariableReadNode + # + # source://yarp//lib/yarp/node.rb#4098 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4093 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4109 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#4079 + def name; end +end + +# Represents writing to an instance variable in a context that doesn't have an explicit value. +# +# @foo, @bar = baz +# ^^^^ ^^^^ +# +# source://yarp//lib/yarp/node.rb#4118 +class YARP::InstanceVariableTargetNode < ::YARP::Node + # def initialize: (name: Symbol, location: Location) -> void + # + # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#4123 + def initialize(name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4129 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4134 + def child_nodes; end + + # def copy: (**params) -> InstanceVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#4139 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4134 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4150 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#4120 + def name; end +end + +# Represents writing to an instance variable. +# +# @foo = 1 +# ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4159 +class YARP::InstanceVariableWriteNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void + # + # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#4173 + def initialize(name, name_loc, value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4182 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4187 + def child_nodes; end + + # def copy: (**params) -> InstanceVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#4192 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4187 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4206 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#4161 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#4164 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#4211 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#4170 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#4167 + def value; end +end + +# Represents an integer number literal. +# +# 1 +# ^ +# +# source://yarp//lib/yarp.rb#348 +class YARP::IntegerNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [IntegerNode] a new instance of IntegerNode + # + # source://yarp//lib/yarp/node.rb#4222 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4227 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4232 + def child_nodes; end + + # def copy: (**params) -> IntegerNode + # + # source://yarp//lib/yarp/node.rb#4237 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4232 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4247 + def deconstruct_keys(keys); end + + # source://yarp//lib/yarp.rb#349 + def value; end +end + +# Represents a regular expression literal that contains interpolation. +# +# /foo #{bar} baz/ +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4256 +class YARP::InterpolatedRegularExpressionNode < ::YARP::Node + # def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> void + # + # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode + # + # source://yarp//lib/yarp/node.rb#4270 + def initialize(opening_loc, parts, closing_loc, flags, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4279 + def accept(visitor); end + + # def ascii_8bit?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4343 + def ascii_8bit?; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4289 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#4318 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#4264 + def closing_loc; end + + # def copy: (**params) -> InterpolatedRegularExpressionNode + # + # source://yarp//lib/yarp/node.rb#4294 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4289 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4308 + def deconstruct_keys(keys); end + + # def euc_jp?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4338 + def euc_jp?; end + + # def extended?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4333 + def extended?; end + + # attr_reader flags: Integer + # + # source://yarp//lib/yarp/node.rb#4267 + def flags; end + + # def ignore_case?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4323 + def ignore_case?; end + + # def multi_line?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4328 + def multi_line?; end + + # def once?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4358 + def once?; end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#4313 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#4258 + def opening_loc; end + + # attr_reader parts: Array[Node] + # + # source://yarp//lib/yarp/node.rb#4261 + def parts; end + + # source://yarp//lib/yarp/node.rb#4283 + def set_newline_flag(newline_marked); end + + # def utf_8?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4353 + def utf_8?; end + + # def windows_31j?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#4348 + def windows_31j?; end +end + +# Represents a string literal that contains interpolation. +# +# "foo #{bar} baz" +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4367 +class YARP::InterpolatedStringNode < ::YARP::Node + # def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void + # + # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode + # + # source://yarp//lib/yarp/node.rb#4378 + def initialize(opening_loc, parts, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4386 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4396 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#4424 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#4375 + def closing_loc; end + + # def copy: (**params) -> InterpolatedStringNode + # + # source://yarp//lib/yarp/node.rb#4401 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4396 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4414 + def deconstruct_keys(keys); end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#4419 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#4369 + def opening_loc; end + + # attr_reader parts: Array[Node] + # + # source://yarp//lib/yarp/node.rb#4372 + def parts; end + + # source://yarp//lib/yarp/node.rb#4390 + def set_newline_flag(newline_marked); end +end + +# Represents a symbol literal that contains interpolation. +# +# :"foo #{bar} baz" +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4433 +class YARP::InterpolatedSymbolNode < ::YARP::Node + # def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void + # + # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode + # + # source://yarp//lib/yarp/node.rb#4444 + def initialize(opening_loc, parts, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4452 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4462 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#4490 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#4441 + def closing_loc; end + + # def copy: (**params) -> InterpolatedSymbolNode + # + # source://yarp//lib/yarp/node.rb#4467 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4462 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4480 + def deconstruct_keys(keys); end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#4485 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#4435 + def opening_loc; end + + # attr_reader parts: Array[Node] + # + # source://yarp//lib/yarp/node.rb#4438 + def parts; end + + # source://yarp//lib/yarp/node.rb#4456 + def set_newline_flag(newline_marked); end +end + +# Represents an xstring literal that contains interpolation. +# +# `foo #{bar} baz` +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4499 +class YARP::InterpolatedXStringNode < ::YARP::Node + # def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void + # + # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode + # + # source://yarp//lib/yarp/node.rb#4510 + def initialize(opening_loc, parts, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4518 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4528 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#4556 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#4507 + def closing_loc; end + + # def copy: (**params) -> InterpolatedXStringNode + # + # source://yarp//lib/yarp/node.rb#4533 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4528 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4546 + def deconstruct_keys(keys); end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#4551 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#4501 + def opening_loc; end + + # attr_reader parts: Array[Node] + # + # source://yarp//lib/yarp/node.rb#4504 + def parts; end + + # source://yarp//lib/yarp/node.rb#4522 + def set_newline_flag(newline_marked); end +end + +# Represents a hash literal without opening and closing braces. +# +# foo(a: b) +# ^^^^ +# +# source://yarp//lib/yarp/node.rb#4565 +class YARP::KeywordHashNode < ::YARP::Node + # def initialize: (elements: Array[Node], location: Location) -> void + # + # @return [KeywordHashNode] a new instance of KeywordHashNode + # + # source://yarp//lib/yarp/node.rb#4570 + def initialize(elements, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4576 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4581 + def child_nodes; end + + # def copy: (**params) -> KeywordHashNode + # + # source://yarp//lib/yarp/node.rb#4586 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4581 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4597 + def deconstruct_keys(keys); end + + # attr_reader elements: Array[Node] + # + # source://yarp//lib/yarp/node.rb#4567 + def elements; end +end + +# Represents a keyword parameter to a method, block, or lambda definition. +# +# def a(b:) +# ^^ +# end +# +# def a(b: 1) +# ^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#4611 +class YARP::KeywordParameterNode < ::YARP::Node + # def initialize: (name_loc: Location, value: Node?, location: Location) -> void + # + # @return [KeywordParameterNode] a new instance of KeywordParameterNode + # + # source://yarp//lib/yarp/node.rb#4619 + def initialize(name_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4626 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4631 + def child_nodes; end + + # def copy: (**params) -> KeywordParameterNode + # + # source://yarp//lib/yarp/node.rb#4636 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4631 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4648 + def deconstruct_keys(keys); end + + # def name: () -> String + # + # source://yarp//lib/yarp/node.rb#4653 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#4613 + def name_loc; end + + # attr_reader value: Node? + # + # source://yarp//lib/yarp/node.rb#4616 + def value; end +end + +# Represents a keyword rest parameter to a method, block, or lambda definition. +# +# def a(**b) +# ^^^ +# end +# +# source://yarp//lib/yarp/node.rb#4663 +class YARP::KeywordRestParameterNode < ::YARP::Node + # def initialize: (operator_loc: Location, name_loc: Location?, location: Location) -> void + # + # @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode + # + # source://yarp//lib/yarp/node.rb#4671 + def initialize(operator_loc, name_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4678 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4683 + def child_nodes; end + + # def copy: (**params) -> KeywordRestParameterNode + # + # source://yarp//lib/yarp/node.rb#4688 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4683 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4700 + def deconstruct_keys(keys); end + + # def name: () -> String? + # + # source://yarp//lib/yarp/node.rb#4710 + def name; end + + # attr_reader name_loc: Location? + # + # source://yarp//lib/yarp/node.rb#4668 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#4705 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#4665 + def operator_loc; end +end + +# Represents using a lambda literal (not the lambda method call). +# +# ->(value) { value * 2 } +# ^^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4719 +class YARP::LambdaNode < ::YARP::Node + # def initialize: (locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode?, body: Node?, location: Location) -> void + # + # @return [LambdaNode] a new instance of LambdaNode + # + # source://yarp//lib/yarp/node.rb#4739 + def initialize(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4750 + def accept(visitor); end + + # attr_reader body: Node? + # + # source://yarp//lib/yarp/node.rb#4736 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4755 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#4791 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#4730 + def closing_loc; end + + # def copy: (**params) -> LambdaNode + # + # source://yarp//lib/yarp/node.rb#4760 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4755 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4776 + def deconstruct_keys(keys); end + + # attr_reader locals: Array[Symbol] + # + # source://yarp//lib/yarp/node.rb#4721 + def locals; end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#4786 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#4727 + def opening_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#4781 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#4724 + def operator_loc; end + + # attr_reader parameters: BlockParametersNode? + # + # source://yarp//lib/yarp/node.rb#4733 + def parameters; end +end + +# This class is responsible for lexing the source using YARP and then +# converting those tokens to be compatible with Ripper. In the vast majority +# of cases, this is a one-to-one mapping of the token type. Everything else +# generally lines up. However, there are a few cases that require special +# handling. +# +# source://yarp//lib/yarp/lex_compat.rb#11 +class YARP::LexCompat + # @return [LexCompat] a new instance of LexCompat + # + # source://yarp//lib/yarp/lex_compat.rb#554 + def initialize(source, filepath = T.unsafe(nil)); end + + # Returns the value of attribute filepath. + # + # source://yarp//lib/yarp/lex_compat.rb#552 + def filepath; end + + # source://yarp//lib/yarp/lex_compat.rb#559 + def result; end + + # Returns the value of attribute source. + # + # source://yarp//lib/yarp/lex_compat.rb#552 + def source; end +end + +# Ripper doesn't include the rest of the token in the event, so we need to +# trim it down to just the content on the first line when comparing. +# +# source://yarp//lib/yarp/lex_compat.rb#205 +class YARP::LexCompat::EndContentToken < ::YARP::LexCompat::Token + # source://yarp//lib/yarp/lex_compat.rb#206 + def ==(other); end +end + +# A heredoc in this case is a list of tokens that belong to the body of the +# heredoc that should be appended onto the list of tokens when the heredoc +# closes. +# +# source://yarp//lib/yarp/lex_compat.rb#266 +module YARP::LexCompat::Heredoc + class << self + # Here we will split between the two types of heredocs and return the + # object that will store their tokens. + # + # source://yarp//lib/yarp/lex_compat.rb#540 + def build(opening); end + end +end + +# Dash heredocs are a little more complicated. They are a list of tokens +# that need to be split on "\\\n" to mimic Ripper's behavior. We also need +# to keep track of the state that the heredoc was opened in. +# +# source://yarp//lib/yarp/lex_compat.rb#290 +class YARP::LexCompat::Heredoc::DashHeredoc + # @return [DashHeredoc] a new instance of DashHeredoc + # + # source://yarp//lib/yarp/lex_compat.rb#293 + def initialize(split); end + + # source://yarp//lib/yarp/lex_compat.rb#298 + def <<(token); end + + # Returns the value of attribute split. + # + # source://yarp//lib/yarp/lex_compat.rb#291 + def split; end + + # source://yarp//lib/yarp/lex_compat.rb#302 + def to_a; end + + # Returns the value of attribute tokens. + # + # source://yarp//lib/yarp/lex_compat.rb#291 + def tokens; end +end + +# Heredocs that are dedenting heredocs are a little more complicated. +# Ripper outputs on_ignored_sp tokens for the whitespace that is being +# removed from the output. YARP only modifies the node itself and keeps +# the token the same. This simplifies YARP, but makes comparing against +# Ripper much harder because there is a length mismatch. +# +# Fortunately, we already have to pull out the heredoc tokens in order to +# insert them into the stream in the correct order. As such, we can do +# some extra manipulation on the tokens to make them match Ripper's +# output by mirroring the dedent logic that Ripper uses. +# +# source://yarp//lib/yarp/lex_compat.rb#349 +class YARP::LexCompat::Heredoc::DedentingHeredoc + # @return [DedentingHeredoc] a new instance of DedentingHeredoc + # + # source://yarp//lib/yarp/lex_compat.rb#354 + def initialize; end + + # As tokens are coming in, we track the minimum amount of common leading + # whitespace on plain string content tokens. This allows us to later + # remove that amount of whitespace from the beginning of each line. + # + # source://yarp//lib/yarp/lex_compat.rb#364 + def <<(token); end + + # Returns the value of attribute dedent. + # + # source://yarp//lib/yarp/lex_compat.rb#352 + def dedent; end + + # Returns the value of attribute dedent_next. + # + # source://yarp//lib/yarp/lex_compat.rb#352 + def dedent_next; end + + # Returns the value of attribute embexpr_balance. + # + # source://yarp//lib/yarp/lex_compat.rb#352 + def embexpr_balance; end + + # source://yarp//lib/yarp/lex_compat.rb#396 + def to_a; end + + # Returns the value of attribute tokens. + # + # source://yarp//lib/yarp/lex_compat.rb#352 + def tokens; end +end + +# source://yarp//lib/yarp/lex_compat.rb#350 +YARP::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer) + +# Heredocs that are no dash or tilde heredocs are just a list of tokens. +# We need to keep them around so that we can insert them in the correct +# order back into the token stream and set the state of the last token to +# the state that the heredoc was opened in. +# +# source://yarp//lib/yarp/lex_compat.rb#271 +class YARP::LexCompat::Heredoc::PlainHeredoc + # @return [PlainHeredoc] a new instance of PlainHeredoc + # + # source://yarp//lib/yarp/lex_compat.rb#274 + def initialize; end + + # source://yarp//lib/yarp/lex_compat.rb#278 + def <<(token); end + + # source://yarp//lib/yarp/lex_compat.rb#282 + def to_a; end + + # Returns the value of attribute tokens. + # + # source://yarp//lib/yarp/lex_compat.rb#272 + def tokens; end +end + +# Ident tokens for the most part are exactly the same, except sometimes we +# know an ident is a local when ripper doesn't (when they are introduced +# through named captures in regular expressions). In that case we don't +# compare the state. +# +# source://yarp//lib/yarp/lex_compat.rb#223 +class YARP::LexCompat::IdentToken < ::YARP::LexCompat::Token + # source://yarp//lib/yarp/lex_compat.rb#224 + def ==(other); end +end + +# Tokens where state should be ignored +# used for :on_comment, :on_heredoc_end, :on_embexpr_end +# +# source://yarp//lib/yarp/lex_compat.rb#213 +class YARP::LexCompat::IgnoreStateToken < ::YARP::LexCompat::Token + # source://yarp//lib/yarp/lex_compat.rb#214 + def ==(other); end +end + +# Ignored newlines can occasionally have a LABEL state attached to them, so +# we compare the state differently here. +# +# source://yarp//lib/yarp/lex_compat.rb#234 +class YARP::LexCompat::IgnoredNewlineToken < ::YARP::LexCompat::Token + # source://yarp//lib/yarp/lex_compat.rb#235 + def ==(other); end +end + +# If we have an identifier that follows a method name like: +# +# def foo bar +# +# then Ripper will mark bar as END|LABEL if there is a local in a parent +# scope named bar because it hasn't pushed the local table yet. We do this +# more accurately, so we need to allow comparing against both END and +# END|LABEL. +# +# source://yarp//lib/yarp/lex_compat.rb#254 +class YARP::LexCompat::ParamToken < ::YARP::LexCompat::Token + # source://yarp//lib/yarp/lex_compat.rb#255 + def ==(other); end +end + +# This is a mapping of YARP token types to Ripper token types. This is a +# many-to-one mapping because we split up our token types, whereas Ripper +# tends to group them. +# +# source://yarp//lib/yarp/lex_compat.rb#15 +YARP::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash) + +# When we produce tokens, we produce the same arrays that Ripper does. +# However, we add a couple of convenience methods onto them to make them a +# little easier to work with. We delegate all other methods to the array. +# +# source://yarp//lib/yarp/lex_compat.rb#185 +class YARP::LexCompat::Token < ::SimpleDelegator + # source://yarp//lib/yarp/lex_compat.rb#190 + def event; end + + # source://yarp//lib/yarp/lex_compat.rb#186 + def location; end + + # source://yarp//lib/yarp/lex_compat.rb#198 + def state; end + + # source://yarp//lib/yarp/lex_compat.rb#194 + def value; end +end + +# Represents the use of the `&&=` operator for assignment to a local variable. +# +# target &&= value +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4800 +class YARP::LocalVariableAndWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void + # + # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#4817 + def initialize(name_loc, operator_loc, value, name, depth, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4827 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4832 + def child_nodes; end + + # def copy: (**params) -> LocalVariableAndWriteNode + # + # source://yarp//lib/yarp/node.rb#4837 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4832 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4852 + def deconstruct_keys(keys); end + + # attr_reader depth: Integer + # + # source://yarp//lib/yarp/node.rb#4814 + def depth; end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#4811 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#4802 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#4857 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#4805 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#4808 + def value; end +end + +# Represents assigning to a local variable using an operator that isn't `=`. +# +# target += value +# ^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4866 +class YARP::LocalVariableOperatorWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location) -> void + # + # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#4886 + def initialize(name_loc, operator_loc, value, name, operator, depth, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4897 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4902 + def child_nodes; end + + # def copy: (**params) -> LocalVariableOperatorWriteNode + # + # source://yarp//lib/yarp/node.rb#4907 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4902 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4923 + def deconstruct_keys(keys); end + + # attr_reader depth: Integer + # + # source://yarp//lib/yarp/node.rb#4883 + def depth; end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#4877 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#4868 + def name_loc; end + + # attr_reader operator: Symbol + # + # source://yarp//lib/yarp/node.rb#4880 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#4871 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#4874 + def value; end +end + +# Represents the use of the `||=` operator for assignment to a local variable. +# +# target ||= value +# ^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#4932 +class YARP::LocalVariableOrWriteNode < ::YARP::Node + # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void + # + # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#4949 + def initialize(name_loc, operator_loc, value, name, depth, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#4959 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4964 + def child_nodes; end + + # def copy: (**params) -> LocalVariableOrWriteNode + # + # source://yarp//lib/yarp/node.rb#4969 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#4964 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#4984 + def deconstruct_keys(keys); end + + # attr_reader depth: Integer + # + # source://yarp//lib/yarp/node.rb#4946 + def depth; end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#4943 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#4934 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#4989 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#4937 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#4940 + def value; end +end + +# Represents reading a local variable. Note that this requires that a local +# variable of the same name has already been written to in the same scope, +# otherwise it is parsed as a method call. +# +# foo +# ^^^ +# +# source://yarp//lib/yarp/node.rb#5000 +class YARP::LocalVariableReadNode < ::YARP::Node + # def initialize: (name: Symbol, depth: Integer, location: Location) -> void + # + # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode + # + # source://yarp//lib/yarp/node.rb#5008 + def initialize(name, depth, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5015 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5020 + def child_nodes; end + + # def copy: (**params) -> LocalVariableReadNode + # + # source://yarp//lib/yarp/node.rb#5025 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5020 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5037 + def deconstruct_keys(keys); end + + # attr_reader depth: Integer + # + # source://yarp//lib/yarp/node.rb#5005 + def depth; end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#5002 + def name; end +end + +# Represents writing to a local variable in a context that doesn't have an explicit value. +# +# foo, bar = baz +# ^^^ ^^^ +# +# source://yarp//lib/yarp/node.rb#5046 +class YARP::LocalVariableTargetNode < ::YARP::Node + # def initialize: (name: Symbol, depth: Integer, location: Location) -> void + # + # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#5054 + def initialize(name, depth, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5061 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5066 + def child_nodes; end + + # def copy: (**params) -> LocalVariableTargetNode + # + # source://yarp//lib/yarp/node.rb#5071 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5066 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5083 + def deconstruct_keys(keys); end + + # attr_reader depth: Integer + # + # source://yarp//lib/yarp/node.rb#5051 + def depth; end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#5048 + def name; end +end + +# Represents writing to a local variable. +# +# foo = 1 +# ^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5092 +class YARP::LocalVariableWriteNode < ::YARP::Node + # def initialize: (name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void + # + # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#5109 + def initialize(name, depth, name_loc, value, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5119 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5124 + def child_nodes; end + + # def copy: (**params) -> LocalVariableWriteNode + # + # source://yarp//lib/yarp/node.rb#5129 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5124 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5144 + def deconstruct_keys(keys); end + + # attr_reader depth: Integer + # + # source://yarp//lib/yarp/node.rb#5097 + def depth; end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#5094 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#5100 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#5149 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5106 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#5103 + def value; end +end + +# This represents a location in the source. +# +# source://yarp//lib/yarp.rb#37 +class YARP::Location + # @return [Location] a new instance of Location + # + # source://yarp//lib/yarp.rb#49 + def initialize(source, start_offset, length); end + + # source://yarp//lib/yarp.rb#109 + def ==(other); end + + # Create a new location object with the given options. + # + # source://yarp//lib/yarp.rb#56 + def copy(**options); end + + # source://yarp//lib/yarp.rb#101 + def deconstruct_keys(keys); end + + # The column number in bytes where this location ends from the start of the + # line. + # + # source://yarp//lib/yarp.rb#97 + def end_column; end + + # The line number where this location ends. + # + # source://yarp//lib/yarp.rb#85 + def end_line; end + + # The byte offset from the beginning of the source where this location ends. + # + # source://yarp//lib/yarp.rb#75 + def end_offset; end + + # Returns a string representation of this location. + # + # source://yarp//lib/yarp.rb#65 + def inspect; end + + # Returns a new location that stretches from this location to the given + # other location. Raises an error if this location is not before the other + # location or if they don't share the same source. + # + # source://yarp//lib/yarp.rb#118 + def join(other); end + + # The length of this location in bytes. + # + # source://yarp//lib/yarp.rb#47 + def length; end + + # source://yarp//lib/yarp.rb#105 + def pretty_print(q); end + + # The source code that this location represents. + # + # source://yarp//lib/yarp.rb#70 + def slice; end + + # The column number in bytes where this location starts from the start of + # the line. + # + # source://yarp//lib/yarp.rb#91 + def start_column; end + + # The line number where this location starts. + # + # source://yarp//lib/yarp.rb#80 + def start_line; end + + # The byte offset from the beginning of the source where this location + # starts. + # + # source://yarp//lib/yarp.rb#44 + def start_offset; end + + protected + + # Returns the value of attribute source. + # + # source://yarp//lib/yarp.rb#40 + def source; end + + class << self + # source://yarp//lib/yarp.rb#125 + def null; end + end +end + +# source://yarp//lib/yarp/node.rb#7991 +module YARP::LoopFlags; end + +# a loop after a begin statement, so the body is executed first before the condition +# +# source://yarp//lib/yarp/node.rb#7993 +YARP::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer) + +# Represents the use of the modifier `in` operator. +# +# foo in bar +# ^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5158 +class YARP::MatchPredicateNode < ::YARP::Node + # def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void + # + # @return [MatchPredicateNode] a new instance of MatchPredicateNode + # + # source://yarp//lib/yarp/node.rb#5169 + def initialize(value, pattern, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5177 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5182 + def child_nodes; end + + # def copy: (**params) -> MatchPredicateNode + # + # source://yarp//lib/yarp/node.rb#5187 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5182 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5200 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#5205 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5166 + def operator_loc; end + + # attr_reader pattern: Node + # + # source://yarp//lib/yarp/node.rb#5163 + def pattern; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#5160 + def value; end +end + +# Represents the use of the `=>` operator. +# +# foo => bar +# ^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5214 +class YARP::MatchRequiredNode < ::YARP::Node + # def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void + # + # @return [MatchRequiredNode] a new instance of MatchRequiredNode + # + # source://yarp//lib/yarp/node.rb#5225 + def initialize(value, pattern, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5233 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5238 + def child_nodes; end + + # def copy: (**params) -> MatchRequiredNode + # + # source://yarp//lib/yarp/node.rb#5243 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5238 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5256 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#5261 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5222 + def operator_loc; end + + # attr_reader pattern: Node + # + # source://yarp//lib/yarp/node.rb#5219 + def pattern; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#5216 + def value; end +end + +# Represents a node that is missing from the source and results in a syntax +# error. +# +# source://yarp//lib/yarp/node.rb#5268 +class YARP::MissingNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [MissingNode] a new instance of MissingNode + # + # source://yarp//lib/yarp/node.rb#5270 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5275 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5280 + def child_nodes; end + + # def copy: (**params) -> MissingNode + # + # source://yarp//lib/yarp/node.rb#5285 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5280 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5295 + def deconstruct_keys(keys); end +end + +# Represents a module declaration involving the `module` keyword. +# +# module Foo end +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5304 +class YARP::ModuleNode < ::YARP::Node + # def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: String, location: Location) -> void + # + # @return [ModuleNode] a new instance of ModuleNode + # + # source://yarp//lib/yarp/node.rb#5324 + def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5335 + def accept(visitor); end + + # attr_reader body: Node? + # + # source://yarp//lib/yarp/node.rb#5315 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5340 + def child_nodes; end + + # attr_reader constant_path: Node + # + # source://yarp//lib/yarp/node.rb#5312 + def constant_path; end + + # def copy: (**params) -> ModuleNode + # + # source://yarp//lib/yarp/node.rb#5345 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5340 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5361 + def deconstruct_keys(keys); end + + # def end_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#5371 + def end_keyword; end + + # attr_reader end_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#5318 + def end_keyword_loc; end + + # attr_reader locals: Array[Symbol] + # + # source://yarp//lib/yarp/node.rb#5306 + def locals; end + + # def module_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#5366 + def module_keyword; end + + # attr_reader module_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#5309 + def module_keyword_loc; end + + # attr_reader name: String + # + # source://yarp//lib/yarp/node.rb#5321 + def name; end +end + +# Represents a multi-target expression. +# +# a, b, c = 1, 2, 3 +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5380 +class YARP::MultiWriteNode < ::YARP::Node + # def initialize: (targets: Array[Node], operator_loc: Location?, value: Node?, lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void + # + # @return [MultiWriteNode] a new instance of MultiWriteNode + # + # source://yarp//lib/yarp/node.rb#5397 + def initialize(targets, operator_loc, value, lparen_loc, rparen_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5407 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5412 + def child_nodes; end + + # def copy: (**params) -> MultiWriteNode + # + # source://yarp//lib/yarp/node.rb#5417 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5412 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5432 + def deconstruct_keys(keys); end + + # def lparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#5442 + def lparen; end + + # attr_reader lparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#5391 + def lparen_loc; end + + # def operator: () -> String? + # + # source://yarp//lib/yarp/node.rb#5437 + def operator; end + + # attr_reader operator_loc: Location? + # + # source://yarp//lib/yarp/node.rb#5385 + def operator_loc; end + + # def rparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#5447 + def rparen; end + + # attr_reader rparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#5394 + def rparen_loc; end + + # attr_reader targets: Array[Node] + # + # source://yarp//lib/yarp/node.rb#5382 + def targets; end + + # attr_reader value: Node? + # + # source://yarp//lib/yarp/node.rb#5388 + def value; end +end + +# This visitor walks through the tree and copies each node as it is being +# visited. This is useful for consumers that want to mutate the tree, as you +# can change subtrees in place without effecting the rest of the tree. +# +# source://yarp//lib/yarp/mutation_visitor.rb#12 +class YARP::MutationVisitor < ::YARP::BasicVisitor + # Copy a AliasNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#14 + def visit_alias_node(node); end + + # Copy a AlternationPatternNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#19 + def visit_alternation_pattern_node(node); end + + # Copy a AndNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#24 + def visit_and_node(node); end + + # Copy a ArgumentsNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#29 + def visit_arguments_node(node); end + + # Copy a ArrayNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#34 + def visit_array_node(node); end + + # Copy a ArrayPatternNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#39 + def visit_array_pattern_node(node); end + + # Copy a AssocNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#44 + def visit_assoc_node(node); end + + # Copy a AssocSplatNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#49 + def visit_assoc_splat_node(node); end + + # Copy a BackReferenceReadNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#54 + def visit_back_reference_read_node(node); end + + # Copy a BeginNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#59 + def visit_begin_node(node); end + + # Copy a BlockArgumentNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#64 + def visit_block_argument_node(node); end + + # Copy a BlockNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#69 + def visit_block_node(node); end + + # Copy a BlockParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#74 + def visit_block_parameter_node(node); end + + # Copy a BlockParametersNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#79 + def visit_block_parameters_node(node); end + + # Copy a BreakNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#84 + def visit_break_node(node); end + + # Copy a CallNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#89 + def visit_call_node(node); end + + # Copy a CallOperatorAndWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#94 + def visit_call_operator_and_write_node(node); end + + # Copy a CallOperatorOrWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#99 + def visit_call_operator_or_write_node(node); end + + # Copy a CallOperatorWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#104 + def visit_call_operator_write_node(node); end + + # Copy a CapturePatternNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#109 + def visit_capture_pattern_node(node); end + + # Copy a CaseNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#114 + def visit_case_node(node); end + + # Copy a ClassNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#119 + def visit_class_node(node); end + + # Copy a ClassVariableAndWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#124 + def visit_class_variable_and_write_node(node); end + + # Copy a ClassVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#129 + def visit_class_variable_operator_write_node(node); end + + # Copy a ClassVariableOrWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#134 + def visit_class_variable_or_write_node(node); end + + # Copy a ClassVariableReadNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#139 + def visit_class_variable_read_node(node); end + + # Copy a ClassVariableTargetNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#144 + def visit_class_variable_target_node(node); end + + # Copy a ClassVariableWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#149 + def visit_class_variable_write_node(node); end + + # Copy a ConstantAndWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#154 + def visit_constant_and_write_node(node); end + + # Copy a ConstantOperatorWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#159 + def visit_constant_operator_write_node(node); end + + # Copy a ConstantOrWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#164 + def visit_constant_or_write_node(node); end + + # Copy a ConstantPathAndWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#169 + def visit_constant_path_and_write_node(node); end + + # Copy a ConstantPathNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#174 + def visit_constant_path_node(node); end + + # Copy a ConstantPathOperatorWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#179 + def visit_constant_path_operator_write_node(node); end + + # Copy a ConstantPathOrWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#184 + def visit_constant_path_or_write_node(node); end + + # Copy a ConstantPathTargetNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#189 + def visit_constant_path_target_node(node); end + + # Copy a ConstantPathWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#194 + def visit_constant_path_write_node(node); end + + # Copy a ConstantReadNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#199 + def visit_constant_read_node(node); end + + # Copy a ConstantTargetNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#204 + def visit_constant_target_node(node); end + + # Copy a ConstantWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#209 + def visit_constant_write_node(node); end + + # Copy a DefNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#214 + def visit_def_node(node); end + + # Copy a DefinedNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#219 + def visit_defined_node(node); end + + # Copy a ElseNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#224 + def visit_else_node(node); end + + # Copy a EmbeddedStatementsNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#229 + def visit_embedded_statements_node(node); end + + # Copy a EmbeddedVariableNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#234 + def visit_embedded_variable_node(node); end + + # Copy a EnsureNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#239 + def visit_ensure_node(node); end + + # Copy a FalseNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#244 + def visit_false_node(node); end + + # Copy a FindPatternNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#249 + def visit_find_pattern_node(node); end + + # Copy a FlipFlopNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#254 + def visit_flip_flop_node(node); end + + # Copy a FloatNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#259 + def visit_float_node(node); end + + # Copy a ForNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#264 + def visit_for_node(node); end + + # Copy a ForwardingArgumentsNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#269 + def visit_forwarding_arguments_node(node); end + + # Copy a ForwardingParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#274 + def visit_forwarding_parameter_node(node); end + + # Copy a ForwardingSuperNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#279 + def visit_forwarding_super_node(node); end + + # Copy a GlobalVariableAndWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#284 + def visit_global_variable_and_write_node(node); end + + # Copy a GlobalVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#289 + def visit_global_variable_operator_write_node(node); end + + # Copy a GlobalVariableOrWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#294 + def visit_global_variable_or_write_node(node); end + + # Copy a GlobalVariableReadNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#299 + def visit_global_variable_read_node(node); end + + # Copy a GlobalVariableTargetNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#304 + def visit_global_variable_target_node(node); end + + # Copy a GlobalVariableWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#309 + def visit_global_variable_write_node(node); end + + # Copy a HashNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#314 + def visit_hash_node(node); end + + # Copy a HashPatternNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#319 + def visit_hash_pattern_node(node); end + + # Copy a IfNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#324 + def visit_if_node(node); end + + # Copy a ImaginaryNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#329 + def visit_imaginary_node(node); end + + # Copy a InNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#334 + def visit_in_node(node); end + + # Copy a InstanceVariableAndWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#339 + def visit_instance_variable_and_write_node(node); end + + # Copy a InstanceVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#344 + def visit_instance_variable_operator_write_node(node); end + + # Copy a InstanceVariableOrWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#349 + def visit_instance_variable_or_write_node(node); end + + # Copy a InstanceVariableReadNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#354 + def visit_instance_variable_read_node(node); end + + # Copy a InstanceVariableTargetNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#359 + def visit_instance_variable_target_node(node); end + + # Copy a InstanceVariableWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#364 + def visit_instance_variable_write_node(node); end + + # Copy a IntegerNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#369 + def visit_integer_node(node); end + + # Copy a InterpolatedRegularExpressionNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#374 + def visit_interpolated_regular_expression_node(node); end + + # Copy a InterpolatedStringNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#379 + def visit_interpolated_string_node(node); end + + # Copy a InterpolatedSymbolNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#384 + def visit_interpolated_symbol_node(node); end + + # Copy a InterpolatedXStringNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#389 + def visit_interpolated_x_string_node(node); end + + # Copy a KeywordHashNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#394 + def visit_keyword_hash_node(node); end + + # Copy a KeywordParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#399 + def visit_keyword_parameter_node(node); end + + # Copy a KeywordRestParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#404 + def visit_keyword_rest_parameter_node(node); end + + # Copy a LambdaNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#409 + def visit_lambda_node(node); end + + # Copy a LocalVariableAndWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#414 + def visit_local_variable_and_write_node(node); end + + # Copy a LocalVariableOperatorWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#419 + def visit_local_variable_operator_write_node(node); end + + # Copy a LocalVariableOrWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#424 + def visit_local_variable_or_write_node(node); end + + # Copy a LocalVariableReadNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#429 + def visit_local_variable_read_node(node); end + + # Copy a LocalVariableTargetNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#434 + def visit_local_variable_target_node(node); end + + # Copy a LocalVariableWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#439 + def visit_local_variable_write_node(node); end + + # Copy a MatchPredicateNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#444 + def visit_match_predicate_node(node); end + + # Copy a MatchRequiredNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#449 + def visit_match_required_node(node); end + + # Copy a MissingNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#454 + def visit_missing_node(node); end + + # Copy a ModuleNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#459 + def visit_module_node(node); end + + # Copy a MultiWriteNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#464 + def visit_multi_write_node(node); end + + # Copy a NextNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#469 + def visit_next_node(node); end + + # Copy a NilNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#474 + def visit_nil_node(node); end + + # Copy a NoKeywordsParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#479 + def visit_no_keywords_parameter_node(node); end + + # Copy a NumberedReferenceReadNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#484 + def visit_numbered_reference_read_node(node); end + + # Copy a OptionalParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#489 + def visit_optional_parameter_node(node); end + + # Copy a OrNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#494 + def visit_or_node(node); end + + # Copy a ParametersNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#499 + def visit_parameters_node(node); end + + # Copy a ParenthesesNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#504 + def visit_parentheses_node(node); end + + # Copy a PinnedExpressionNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#509 + def visit_pinned_expression_node(node); end + + # Copy a PinnedVariableNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#514 + def visit_pinned_variable_node(node); end + + # Copy a PostExecutionNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#519 + def visit_post_execution_node(node); end + + # Copy a PreExecutionNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#524 + def visit_pre_execution_node(node); end + + # Copy a ProgramNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#529 + def visit_program_node(node); end + + # Copy a RangeNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#534 + def visit_range_node(node); end + + # Copy a RationalNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#539 + def visit_rational_node(node); end + + # Copy a RedoNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#544 + def visit_redo_node(node); end + + # Copy a RegularExpressionNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#549 + def visit_regular_expression_node(node); end + + # Copy a RequiredDestructuredParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#554 + def visit_required_destructured_parameter_node(node); end + + # Copy a RequiredParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#559 + def visit_required_parameter_node(node); end + + # Copy a RescueModifierNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#564 + def visit_rescue_modifier_node(node); end + + # Copy a RescueNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#569 + def visit_rescue_node(node); end + + # Copy a RestParameterNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#574 + def visit_rest_parameter_node(node); end + + # Copy a RetryNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#579 + def visit_retry_node(node); end + + # Copy a ReturnNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#584 + def visit_return_node(node); end + + # Copy a SelfNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#589 + def visit_self_node(node); end + + # Copy a SingletonClassNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#594 + def visit_singleton_class_node(node); end + + # Copy a SourceEncodingNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#599 + def visit_source_encoding_node(node); end + + # Copy a SourceFileNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#604 + def visit_source_file_node(node); end + + # Copy a SourceLineNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#609 + def visit_source_line_node(node); end + + # Copy a SplatNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#614 + def visit_splat_node(node); end + + # Copy a StatementsNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#619 + def visit_statements_node(node); end + + # Copy a StringConcatNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#624 + def visit_string_concat_node(node); end + + # Copy a StringNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#629 + def visit_string_node(node); end + + # Copy a SuperNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#634 + def visit_super_node(node); end + + # Copy a SymbolNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#639 + def visit_symbol_node(node); end + + # Copy a TrueNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#644 + def visit_true_node(node); end + + # Copy a UndefNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#649 + def visit_undef_node(node); end + + # Copy a UnlessNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#654 + def visit_unless_node(node); end + + # Copy a UntilNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#659 + def visit_until_node(node); end + + # Copy a WhenNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#664 + def visit_when_node(node); end + + # Copy a WhileNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#669 + def visit_while_node(node); end + + # Copy a XStringNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#674 + def visit_x_string_node(node); end + + # Copy a YieldNode node + # + # source://yarp//lib/yarp/mutation_visitor.rb#679 + def visit_yield_node(node); end +end + +# Represents the use of the `next` keyword. +# +# next 1 +# ^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5456 +class YARP::NextNode < ::YARP::Node + # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void + # + # @return [NextNode] a new instance of NextNode + # + # source://yarp//lib/yarp/node.rb#5464 + def initialize(arguments, keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5471 + def accept(visitor); end + + # attr_reader arguments: ArgumentsNode? + # + # source://yarp//lib/yarp/node.rb#5458 + def arguments; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5476 + def child_nodes; end + + # def copy: (**params) -> NextNode + # + # source://yarp//lib/yarp/node.rb#5481 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5476 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5493 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#5498 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#5461 + def keyword_loc; end +end + +# Represents the use of the `nil` keyword. +# +# nil +# ^^^ +# +# source://yarp//lib/yarp/node.rb#5507 +class YARP::NilNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [NilNode] a new instance of NilNode + # + # source://yarp//lib/yarp/node.rb#5509 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5514 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5519 + def child_nodes; end + + # def copy: (**params) -> NilNode + # + # source://yarp//lib/yarp/node.rb#5524 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5519 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5534 + def deconstruct_keys(keys); end +end + +# Represents the use of `**nil` inside method arguments. +# +# def a(**nil) +# ^^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#5544 +class YARP::NoKeywordsParameterNode < ::YARP::Node + # def initialize: (operator_loc: Location, keyword_loc: Location, location: Location) -> void + # + # @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode + # + # source://yarp//lib/yarp/node.rb#5552 + def initialize(operator_loc, keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5559 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5564 + def child_nodes; end + + # def copy: (**params) -> NoKeywordsParameterNode + # + # source://yarp//lib/yarp/node.rb#5569 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5564 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5581 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#5591 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#5549 + def keyword_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#5586 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5546 + def operator_loc; end +end + +# This represents a node in the tree. +# +# source://yarp//lib/yarp.rb#297 +class YARP::Node + # Returns the value of attribute location. + # + # source://yarp//lib/yarp.rb#298 + def location; end + + # @return [Boolean] + # + # source://yarp//lib/yarp.rb#300 + def newline?; end + + # source://yarp//lib/yarp.rb#317 + def pretty_print(q); end + + # source://yarp//lib/yarp.rb#304 + def set_newline_flag(newline_marked); end + + # Slice the location of the node from the source. + # + # source://yarp//lib/yarp.rb#313 + def slice; end +end + +# Represents reading a numbered reference to a capture in the previous match. +# +# $1 +# ^^ +# +# source://yarp//lib/yarp/node.rb#5600 +class YARP::NumberedReferenceReadNode < ::YARP::Node + # def initialize: (number: Integer, location: Location) -> void + # + # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode + # + # source://yarp//lib/yarp/node.rb#5605 + def initialize(number, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5611 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5616 + def child_nodes; end + + # def copy: (**params) -> NumberedReferenceReadNode + # + # source://yarp//lib/yarp/node.rb#5621 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5616 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5632 + def deconstruct_keys(keys); end + + # attr_reader number: Integer + # + # source://yarp//lib/yarp/node.rb#5602 + def number; end +end + +# Represents an optional parameter to a method, block, or lambda definition. +# +# def a(b = 1) +# ^^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#5642 +class YARP::OptionalParameterNode < ::YARP::Node + # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void + # + # @return [OptionalParameterNode] a new instance of OptionalParameterNode + # + # source://yarp//lib/yarp/node.rb#5656 + def initialize(name, name_loc, operator_loc, value, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5665 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5670 + def child_nodes; end + + # def copy: (**params) -> OptionalParameterNode + # + # source://yarp//lib/yarp/node.rb#5675 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5670 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5689 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#5644 + def name; end + + # attr_reader name_loc: Location + # + # source://yarp//lib/yarp/node.rb#5647 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#5694 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5650 + def operator_loc; end + + # attr_reader value: Node + # + # source://yarp//lib/yarp/node.rb#5653 + def value; end +end + +# Represents the use of the `||` operator or the `or` keyword. +# +# left or right +# ^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5703 +class YARP::OrNode < ::YARP::Node + # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void + # + # @return [OrNode] a new instance of OrNode + # + # source://yarp//lib/yarp/node.rb#5714 + def initialize(left, right, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5722 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5727 + def child_nodes; end + + # def copy: (**params) -> OrNode + # + # source://yarp//lib/yarp/node.rb#5732 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5727 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5745 + def deconstruct_keys(keys); end + + # attr_reader left: Node + # + # source://yarp//lib/yarp/node.rb#5705 + def left; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#5750 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5711 + def operator_loc; end + + # attr_reader right: Node + # + # source://yarp//lib/yarp/node.rb#5708 + def right; end +end + +# source://yarp//lib/yarp/pack.rb#4 +module YARP::Pack + class << self + def parse(_arg0, _arg1, _arg2); end + end +end + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::BACK = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::BER = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::COMMENT = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#57 +class YARP::Pack::Directive + # @return [Directive] a new instance of Directive + # + # source://yarp//lib/yarp/pack.rb#60 + def initialize(version, variant, source, type, signed, endian, size, length_type, length); end + + # source://yarp//lib/yarp/pack.rb#98 + def describe; end + + # Returns the value of attribute endian. + # + # source://yarp//lib/yarp/pack.rb#58 + def endian; end + + # Returns the value of attribute length. + # + # source://yarp//lib/yarp/pack.rb#58 + def length; end + + # Returns the value of attribute length_type. + # + # source://yarp//lib/yarp/pack.rb#58 + def length_type; end + + # Returns the value of attribute signed. + # + # source://yarp//lib/yarp/pack.rb#58 + def signed; end + + # Returns the value of attribute size. + # + # source://yarp//lib/yarp/pack.rb#58 + def size; end + + # Returns the value of attribute source. + # + # source://yarp//lib/yarp/pack.rb#58 + def source; end + + # Returns the value of attribute type. + # + # source://yarp//lib/yarp/pack.rb#58 + def type; end + + # Returns the value of attribute variant. + # + # source://yarp//lib/yarp/pack.rb#58 + def variant; end + + # Returns the value of attribute version. + # + # source://yarp//lib/yarp/pack.rb#58 + def version; end +end + +# source://yarp//lib/yarp/pack.rb#72 +YARP::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) + +# source://yarp//lib/yarp/pack.rb#80 +YARP::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) + +# source://yarp//lib/yarp/pack.rb#86 +YARP::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::FLOAT = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#162 +class YARP::Pack::Format + # @return [Format] a new instance of Format + # + # source://yarp//lib/yarp/pack.rb#165 + def initialize(directives, encoding); end + + # source://yarp//lib/yarp/pack.rb#170 + def describe; end + + # Returns the value of attribute directives. + # + # source://yarp//lib/yarp/pack.rb#163 + def directives; end + + # Returns the value of attribute encoding. + # + # source://yarp//lib/yarp/pack.rb#163 + def encoding; end +end + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::INTEGER = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::MOVE = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::NULL = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIGNED = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::SPACE = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol) + +# source://yarp//lib/yarp/pack.rb#54 +YARP::Pack::UTF8 = T.let(T.unsafe(nil), Symbol) + +# Represents the list of parameters on a method, block, or lambda definition. +# +# def a(b, c, d) +# ^^^^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#5760 +class YARP::ParametersNode < ::YARP::Node + # def initialize: (requireds: Array[Node], optionals: Array[Node], posts: Array[Node], rest: RestParameterNode?, keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void + # + # @return [ParametersNode] a new instance of ParametersNode + # + # source://yarp//lib/yarp/node.rb#5783 + def initialize(requireds, optionals, posts, rest, keywords, keyword_rest, block, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5795 + def accept(visitor); end + + # attr_reader block: BlockParameterNode? + # + # source://yarp//lib/yarp/node.rb#5780 + def block; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5800 + def child_nodes; end + + # def copy: (**params) -> ParametersNode + # + # source://yarp//lib/yarp/node.rb#5805 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5800 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5822 + def deconstruct_keys(keys); end + + # attr_reader keyword_rest: Node? + # + # source://yarp//lib/yarp/node.rb#5777 + def keyword_rest; end + + # attr_reader keywords: Array[Node] + # + # source://yarp//lib/yarp/node.rb#5774 + def keywords; end + + # attr_reader optionals: Array[Node] + # + # source://yarp//lib/yarp/node.rb#5765 + def optionals; end + + # attr_reader posts: Array[Node] + # + # source://yarp//lib/yarp/node.rb#5768 + def posts; end + + # attr_reader requireds: Array[Node] + # + # source://yarp//lib/yarp/node.rb#5762 + def requireds; end + + # attr_reader rest: RestParameterNode? + # + # source://yarp//lib/yarp/node.rb#5771 + def rest; end +end + +# Represents a parenthesized expression +# +# (10 + 34) +# ^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5831 +class YARP::ParenthesesNode < ::YARP::Node + # def initialize: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void + # + # @return [ParenthesesNode] a new instance of ParenthesesNode + # + # source://yarp//lib/yarp/node.rb#5842 + def initialize(body, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5850 + def accept(visitor); end + + # attr_reader body: Node? + # + # source://yarp//lib/yarp/node.rb#5833 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5859 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#5887 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#5839 + def closing_loc; end + + # def copy: (**params) -> ParenthesesNode + # + # source://yarp//lib/yarp/node.rb#5864 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5859 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5877 + def deconstruct_keys(keys); end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#5882 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#5836 + def opening_loc; end + + # source://yarp//lib/yarp/node.rb#5854 + def set_newline_flag(newline_marked); end +end + +# This represents an error that was encountered during parsing. +# +# source://yarp//lib/yarp.rb#147 +class YARP::ParseError + # @return [ParseError] a new instance of ParseError + # + # source://yarp//lib/yarp.rb#150 + def initialize(message, location); end + + # source://yarp//lib/yarp.rb#155 + def deconstruct_keys(keys); end + + # Returns the value of attribute location. + # + # source://yarp//lib/yarp.rb#148 + def location; end + + # Returns the value of attribute message. + # + # source://yarp//lib/yarp.rb#148 + def message; end +end + +# This represents the result of a call to ::parse or ::parse_file. It contains +# the AST, any comments that were encounters, and any errors that were +# encountered. +# +# source://yarp//lib/yarp.rb#198 +class YARP::ParseResult + # @return [ParseResult] a new instance of ParseResult + # + # source://yarp//lib/yarp.rb#201 + def initialize(value, comments, errors, warnings, source); end + + # Returns the value of attribute comments. + # + # source://yarp//lib/yarp.rb#199 + def comments; end + + # source://yarp//lib/yarp.rb#209 + def deconstruct_keys(keys); end + + # Returns the value of attribute errors. + # + # source://yarp//lib/yarp.rb#199 + def errors; end + + # @return [Boolean] + # + # source://yarp//lib/yarp.rb#217 + def failure?; end + + # source://yarp//lib/yarp.rb#253 + def mark_newlines; end + + # Returns the value of attribute source. + # + # source://yarp//lib/yarp.rb#199 + def source; end + + # @return [Boolean] + # + # source://yarp//lib/yarp.rb#213 + def success?; end + + # Returns the value of attribute value. + # + # source://yarp//lib/yarp.rb#199 + def value; end + + # Returns the value of attribute warnings. + # + # source://yarp//lib/yarp.rb#199 + def warnings; end +end + +# Keep in sync with Java MarkNewlinesVisitor +# +# source://yarp//lib/yarp.rb#222 +class YARP::ParseResult::MarkNewlinesVisitor < ::YARP::Visitor + # @return [MarkNewlinesVisitor] a new instance of MarkNewlinesVisitor + # + # source://yarp//lib/yarp.rb#223 + def initialize(newline_marked); end + + # source://yarp//lib/yarp.rb#227 + def visit_block_node(node); end + + # source://yarp//lib/yarp.rb#238 + def visit_if_node(node); end + + # source://yarp//lib/yarp.rb#227 + def visit_lambda_node(node); end + + # source://yarp//lib/yarp.rb#244 + def visit_statements_node(node); end + + # source://yarp//lib/yarp.rb#238 + def visit_unless_node(node); end +end + +# This represents a warning that was encountered during parsing. +# +# source://yarp//lib/yarp.rb#161 +class YARP::ParseWarning + # @return [ParseWarning] a new instance of ParseWarning + # + # source://yarp//lib/yarp.rb#164 + def initialize(message, location); end + + # source://yarp//lib/yarp.rb#169 + def deconstruct_keys(keys); end + + # Returns the value of attribute location. + # + # source://yarp//lib/yarp.rb#162 + def location; end + + # Returns the value of attribute message. + # + # source://yarp//lib/yarp.rb#162 + def message; end +end + +# Represents the use of the `^` operator for pinning an expression in a +# pattern matching expression. +# +# foo in ^(bar) +# ^^^^^^ +# +# source://yarp//lib/yarp/node.rb#5897 +class YARP::PinnedExpressionNode < ::YARP::Node + # def initialize: (expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location) -> void + # + # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode + # + # source://yarp//lib/yarp/node.rb#5911 + def initialize(expression, operator_loc, lparen_loc, rparen_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5920 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5925 + def child_nodes; end + + # def copy: (**params) -> PinnedExpressionNode + # + # source://yarp//lib/yarp/node.rb#5930 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5925 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#5944 + def deconstruct_keys(keys); end + + # attr_reader expression: Node + # + # source://yarp//lib/yarp/node.rb#5899 + def expression; end + + # def lparen: () -> String + # + # source://yarp//lib/yarp/node.rb#5954 + def lparen; end + + # attr_reader lparen_loc: Location + # + # source://yarp//lib/yarp/node.rb#5905 + def lparen_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#5949 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5902 + def operator_loc; end + + # def rparen: () -> String + # + # source://yarp//lib/yarp/node.rb#5959 + def rparen; end + + # attr_reader rparen_loc: Location + # + # source://yarp//lib/yarp/node.rb#5908 + def rparen_loc; end +end + +# Represents the use of the `^` operator for pinning a variable in a pattern +# matching expression. +# +# foo in ^bar +# ^^^^ +# +# source://yarp//lib/yarp/node.rb#5969 +class YARP::PinnedVariableNode < ::YARP::Node + # def initialize: (variable: Node, operator_loc: Location, location: Location) -> void + # + # @return [PinnedVariableNode] a new instance of PinnedVariableNode + # + # source://yarp//lib/yarp/node.rb#5977 + def initialize(variable, operator_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#5984 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5989 + def child_nodes; end + + # def copy: (**params) -> PinnedVariableNode + # + # source://yarp//lib/yarp/node.rb#5994 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#5989 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6006 + def deconstruct_keys(keys); end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#6011 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#5974 + def operator_loc; end + + # attr_reader variable: Node + # + # source://yarp//lib/yarp/node.rb#5971 + def variable; end +end + +# Represents the use of the `END` keyword. +# +# END { foo } +# ^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6020 +class YARP::PostExecutionNode < ::YARP::Node + # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void + # + # @return [PostExecutionNode] a new instance of PostExecutionNode + # + # source://yarp//lib/yarp/node.rb#6034 + def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6043 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6048 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#6082 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#6031 + def closing_loc; end + + # def copy: (**params) -> PostExecutionNode + # + # source://yarp//lib/yarp/node.rb#6053 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6048 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6067 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#6072 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#6025 + def keyword_loc; end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#6077 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#6028 + def opening_loc; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#6022 + def statements; end +end + +# Represents the use of the `BEGIN` keyword. +# +# BEGIN { foo } +# ^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6091 +class YARP::PreExecutionNode < ::YARP::Node + # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void + # + # @return [PreExecutionNode] a new instance of PreExecutionNode + # + # source://yarp//lib/yarp/node.rb#6105 + def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6114 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6119 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#6153 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#6102 + def closing_loc; end + + # def copy: (**params) -> PreExecutionNode + # + # source://yarp//lib/yarp/node.rb#6124 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6119 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6138 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#6143 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#6096 + def keyword_loc; end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#6148 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#6099 + def opening_loc; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#6093 + def statements; end +end + +# The top level node of any parse tree. +# +# source://yarp//lib/yarp/node.rb#6159 +class YARP::ProgramNode < ::YARP::Node + # def initialize: (locals: Array[Symbol], statements: StatementsNode, location: Location) -> void + # + # @return [ProgramNode] a new instance of ProgramNode + # + # source://yarp//lib/yarp/node.rb#6167 + def initialize(locals, statements, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6174 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6179 + def child_nodes; end + + # def copy: (**params) -> ProgramNode + # + # source://yarp//lib/yarp/node.rb#6184 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6179 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6196 + def deconstruct_keys(keys); end + + # attr_reader locals: Array[Symbol] + # + # source://yarp//lib/yarp/node.rb#6161 + def locals; end + + # attr_reader statements: StatementsNode + # + # source://yarp//lib/yarp/node.rb#6164 + def statements; end +end + +# source://yarp//lib/yarp/node.rb#7996 +module YARP::RangeFlags; end + +# ... operator +# +# source://yarp//lib/yarp/node.rb#7998 +YARP::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer) + +# Represents the use of the `..` or `...` operators. +# +# 1..2 +# ^^^^ +# +# c if a =~ /left/ ... b =~ /right/ +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6208 +class YARP::RangeNode < ::YARP::Node + # def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void + # + # @return [RangeNode] a new instance of RangeNode + # + # source://yarp//lib/yarp/node.rb#6222 + def initialize(left, right, operator_loc, flags, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6231 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6236 + def child_nodes; end + + # def copy: (**params) -> RangeNode + # + # source://yarp//lib/yarp/node.rb#6241 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6236 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6255 + def deconstruct_keys(keys); end + + # def exclude_end?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6265 + def exclude_end?; end + + # attr_reader flags: Integer + # + # source://yarp//lib/yarp/node.rb#6219 + def flags; end + + # attr_reader left: Node? + # + # source://yarp//lib/yarp/node.rb#6210 + def left; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#6260 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#6216 + def operator_loc; end + + # attr_reader right: Node? + # + # source://yarp//lib/yarp/node.rb#6213 + def right; end +end + +# Represents a rational number literal. +# +# 1.0r +# ^^^^ +# +# source://yarp//lib/yarp.rb#354 +class YARP::RationalNode < ::YARP::Node + # def initialize: (numeric: Node, location: Location) -> void + # + # @return [RationalNode] a new instance of RationalNode + # + # source://yarp//lib/yarp/node.rb#6279 + def initialize(numeric, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6285 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6290 + def child_nodes; end + + # def copy: (**params) -> RationalNode + # + # source://yarp//lib/yarp/node.rb#6295 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6290 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6306 + def deconstruct_keys(keys); end + + # attr_reader numeric: Node + # + # source://yarp//lib/yarp/node.rb#6276 + def numeric; end + + # source://yarp//lib/yarp.rb#355 + def value; end +end + +# Represents the use of the `redo` keyword. +# +# redo +# ^^^^ +# +# source://yarp//lib/yarp/node.rb#6315 +class YARP::RedoNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [RedoNode] a new instance of RedoNode + # + # source://yarp//lib/yarp/node.rb#6317 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6322 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6327 + def child_nodes; end + + # def copy: (**params) -> RedoNode + # + # source://yarp//lib/yarp/node.rb#6332 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6327 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6342 + def deconstruct_keys(keys); end +end + +# source://yarp//lib/yarp/node.rb#8001 +module YARP::RegularExpressionFlags; end + +# n - forces the ASCII-8BIT encoding +# +# source://yarp//lib/yarp/node.rb#8015 +YARP::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer) + +# e - forces the EUC-JP encoding +# +# source://yarp//lib/yarp/node.rb#8012 +YARP::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer) + +# x - ignores whitespace and allows comments in regular expressions +# +# source://yarp//lib/yarp/node.rb#8009 +YARP::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer) + +# i - ignores the case of characters when matching +# +# source://yarp//lib/yarp/node.rb#8003 +YARP::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer) + +# m - allows $ to match the end of lines within strings +# +# source://yarp//lib/yarp/node.rb#8006 +YARP::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer) + +# o - only interpolates values into the regular expression once +# +# source://yarp//lib/yarp/node.rb#8024 +YARP::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer) + +# u - forces the UTF-8 encoding +# +# source://yarp//lib/yarp/node.rb#8021 +YARP::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer) + +# s - forces the Windows-31J encoding +# +# source://yarp//lib/yarp/node.rb#8018 +YARP::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer) + +# Represents a regular expression literal with no interpolation. +# +# /foo/i +# ^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6351 +class YARP::RegularExpressionNode < ::YARP::Node + # def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> void + # + # @return [RegularExpressionNode] a new instance of RegularExpressionNode + # + # source://yarp//lib/yarp/node.rb#6368 + def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6378 + def accept(visitor); end + + # def ascii_8bit?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6443 + def ascii_8bit?; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6383 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#6418 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#6359 + def closing_loc; end + + # def content: () -> String + # + # source://yarp//lib/yarp/node.rb#6413 + def content; end + + # attr_reader content_loc: Location + # + # source://yarp//lib/yarp/node.rb#6356 + def content_loc; end + + # def copy: (**params) -> RegularExpressionNode + # + # source://yarp//lib/yarp/node.rb#6388 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6383 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6403 + def deconstruct_keys(keys); end + + # def euc_jp?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6438 + def euc_jp?; end + + # def extended?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6433 + def extended?; end + + # attr_reader flags: Integer + # + # source://yarp//lib/yarp/node.rb#6365 + def flags; end + + # def ignore_case?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6423 + def ignore_case?; end + + # def multi_line?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6428 + def multi_line?; end + + # def once?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6458 + def once?; end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#6408 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#6353 + def opening_loc; end + + # attr_reader unescaped: String + # + # source://yarp//lib/yarp/node.rb#6362 + def unescaped; end + + # def utf_8?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6453 + def utf_8?; end + + # def windows_31j?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#6448 + def windows_31j?; end +end + +# Represents a destructured required parameter node. +# +# def foo((bar, baz)) +# ^^^^^^^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#6468 +class YARP::RequiredDestructuredParameterNode < ::YARP::Node + # def initialize: (parameters: Array[Node], opening_loc: Location, closing_loc: Location, location: Location) -> void + # + # @return [RequiredDestructuredParameterNode] a new instance of RequiredDestructuredParameterNode + # + # source://yarp//lib/yarp/node.rb#6479 + def initialize(parameters, opening_loc, closing_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6487 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6492 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#6520 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#6476 + def closing_loc; end + + # def copy: (**params) -> RequiredDestructuredParameterNode + # + # source://yarp//lib/yarp/node.rb#6497 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6492 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6510 + def deconstruct_keys(keys); end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#6515 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#6473 + def opening_loc; end + + # attr_reader parameters: Array[Node] + # + # source://yarp//lib/yarp/node.rb#6470 + def parameters; end +end + +# Represents a required parameter to a method, block, or lambda definition. +# +# def a(b) +# ^ +# end +# +# source://yarp//lib/yarp/node.rb#6530 +class YARP::RequiredParameterNode < ::YARP::Node + # def initialize: (name: Symbol, location: Location) -> void + # + # @return [RequiredParameterNode] a new instance of RequiredParameterNode + # + # source://yarp//lib/yarp/node.rb#6535 + def initialize(name, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6541 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6546 + def child_nodes; end + + # def copy: (**params) -> RequiredParameterNode + # + # source://yarp//lib/yarp/node.rb#6551 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6546 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6562 + def deconstruct_keys(keys); end + + # attr_reader name: Symbol + # + # source://yarp//lib/yarp/node.rb#6532 + def name; end +end + +# Represents an expression modified with a rescue. +# +# foo rescue nil +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6571 +class YARP::RescueModifierNode < ::YARP::Node + # def initialize: (expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location) -> void + # + # @return [RescueModifierNode] a new instance of RescueModifierNode + # + # source://yarp//lib/yarp/node.rb#6582 + def initialize(expression, keyword_loc, rescue_expression, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6590 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6599 + def child_nodes; end + + # def copy: (**params) -> RescueModifierNode + # + # source://yarp//lib/yarp/node.rb#6604 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6599 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6617 + def deconstruct_keys(keys); end + + # attr_reader expression: Node + # + # source://yarp//lib/yarp/node.rb#6573 + def expression; end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#6622 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#6576 + def keyword_loc; end + + # attr_reader rescue_expression: Node + # + # source://yarp//lib/yarp/node.rb#6579 + def rescue_expression; end + + # source://yarp//lib/yarp/node.rb#6594 + def set_newline_flag(newline_marked); end +end + +# Represents a rescue statement. +# +# begin +# rescue Foo, *splat, Bar => ex +# ^^^^^^ +# foo +# end +# +# `Foo, *splat, Bar` are in the `exceptions` field. +# `ex` is in the `exception` field. +# +# source://yarp//lib/yarp/node.rb#6637 +class YARP::RescueNode < ::YARP::Node + # def initialize: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> void + # + # @return [RescueNode] a new instance of RescueNode + # + # source://yarp//lib/yarp/node.rb#6657 + def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6668 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6673 + def child_nodes; end + + # attr_reader consequent: RescueNode? + # + # source://yarp//lib/yarp/node.rb#6654 + def consequent; end + + # def copy: (**params) -> RescueNode + # + # source://yarp//lib/yarp/node.rb#6678 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6673 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6694 + def deconstruct_keys(keys); end + + # attr_reader exceptions: Array[Node] + # + # source://yarp//lib/yarp/node.rb#6642 + def exceptions; end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#6699 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#6639 + def keyword_loc; end + + # def operator: () -> String? + # + # source://yarp//lib/yarp/node.rb#6704 + def operator; end + + # attr_reader operator_loc: Location? + # + # source://yarp//lib/yarp/node.rb#6645 + def operator_loc; end + + # attr_reader reference: Node? + # + # source://yarp//lib/yarp/node.rb#6648 + def reference; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#6651 + def statements; end +end + +# Represents a rest parameter to a method, block, or lambda definition. +# +# def a(*b) +# ^^ +# end +# +# source://yarp//lib/yarp/node.rb#6714 +class YARP::RestParameterNode < ::YARP::Node + # def initialize: (operator_loc: Location, name_loc: Location?, location: Location) -> void + # + # @return [RestParameterNode] a new instance of RestParameterNode + # + # source://yarp//lib/yarp/node.rb#6722 + def initialize(operator_loc, name_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6729 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6734 + def child_nodes; end + + # def copy: (**params) -> RestParameterNode + # + # source://yarp//lib/yarp/node.rb#6739 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6734 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6751 + def deconstruct_keys(keys); end + + # def name: () -> String? + # + # source://yarp//lib/yarp/node.rb#6761 + def name; end + + # attr_reader name_loc: Location? + # + # source://yarp//lib/yarp/node.rb#6719 + def name_loc; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#6756 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#6716 + def operator_loc; end +end + +# Represents the use of the `retry` keyword. +# +# retry +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#6770 +class YARP::RetryNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [RetryNode] a new instance of RetryNode + # + # source://yarp//lib/yarp/node.rb#6772 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6777 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6782 + def child_nodes; end + + # def copy: (**params) -> RetryNode + # + # source://yarp//lib/yarp/node.rb#6787 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6782 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6797 + def deconstruct_keys(keys); end +end + +# Represents the use of the `return` keyword. +# +# return 1 +# ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6806 +class YARP::ReturnNode < ::YARP::Node + # def initialize: (keyword_loc: Location, arguments: ArgumentsNode?, location: Location) -> void + # + # @return [ReturnNode] a new instance of ReturnNode + # + # source://yarp//lib/yarp/node.rb#6814 + def initialize(keyword_loc, arguments, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6821 + def accept(visitor); end + + # attr_reader arguments: ArgumentsNode? + # + # source://yarp//lib/yarp/node.rb#6811 + def arguments; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6826 + def child_nodes; end + + # def copy: (**params) -> ReturnNode + # + # source://yarp//lib/yarp/node.rb#6831 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6826 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6843 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#6848 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#6808 + def keyword_loc; end +end + +# This class is meant to provide a compatibility layer between YARP and +# Ripper. It functions by parsing the entire tree first and then walking it +# and executing each of the Ripper callbacks as it goes. +# +# This class is going to necessarily be slower than the native Ripper API. It +# is meant as a stopgap until developers migrate to using YARP. It is also +# meant as a test harness for the YARP parser. +# +# source://yarp//lib/yarp/ripper_compat.rb#13 +class YARP::RipperCompat + # @return [RipperCompat] a new instance of RipperCompat + # + # source://yarp//lib/yarp/ripper_compat.rb#59 + def initialize(source); end + + # Returns the value of attribute column. + # + # source://yarp//lib/yarp/ripper_compat.rb#57 + def column; end + + # Public interface + # + # @return [Boolean] + # + # source://yarp//lib/yarp/ripper_compat.rb#70 + def error?; end + + # Returns the value of attribute lineno. + # + # source://yarp//lib/yarp/ripper_compat.rb#57 + def lineno; end + + # source://yarp//lib/yarp/ripper_compat.rb#74 + def parse; end + + # Returns the value of attribute source. + # + # source://yarp//lib/yarp/ripper_compat.rb#57 + def source; end + + # Visitor methods + # + # source://yarp//lib/yarp/ripper_compat.rb#82 + def visit(node); end + + # source://yarp//lib/yarp/ripper_compat.rb#86 + def visit_call_node(node); end + + # source://yarp//lib/yarp/ripper_compat.rb#100 + def visit_integer_node(node); end + + # source://yarp//lib/yarp/ripper_compat.rb#125 + def visit_program_node(node); end + + # source://yarp//lib/yarp/ripper_compat.rb#105 + def visit_statements_node(node); end + + # source://yarp//lib/yarp/ripper_compat.rb#112 + def visit_token(node); end + + private + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def _dispatch0; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def _dispatch1(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def _dispatch2(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def _dispatch3(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#166 + def _dispatch4(_, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#167 + def _dispatch5(_, _, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#168 + def _dispatch7(_, _, _, _, _, _, _); end + + # This method is responsible for updating lineno and column information + # to reflect the current node. + # + # This method could be drastically improved with some caching on the start + # of every line, but for now it's good enough. + # + # source://yarp//lib/yarp/ripper_compat.rb#151 + def bounds(location); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_BEGIN(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_CHAR(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_END(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on___end__(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_alias(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_alias_error(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_aref(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_aref_field(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_arg_ambiguous(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_arg_paren(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_args_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_args_add_block(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_args_add_star(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_args_forward; end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_args_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_array(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#166 + def on_aryptn(_, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_assign(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_assign_error(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_assoc_new(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_assoc_splat(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_assoclist_from_args(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_backref(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_backtick(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_bare_assoc_hash(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_begin(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_binary(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_block_var(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_blockarg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#166 + def on_bodystmt(_, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_brace_block(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_break(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_call(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_case(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_class(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_class_name_error(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_comma(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_command(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#166 + def on_command_call(_, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_comment(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_const(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_const_path_field(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_const_path_ref(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_const_ref(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_cvar(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_def(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_defined(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#167 + def on_defs(_, _, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_do_block(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_dot2(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_dot3(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_dyna_symbol(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_else(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_elsif(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_embdoc(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_embdoc_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_embdoc_end(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_embexpr_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_embexpr_end(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_embvar(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_ensure(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_excessed_comma; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_fcall(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_field(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_float(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#166 + def on_fndptn(_, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_for(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_gvar(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_hash(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_heredoc_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_heredoc_dedent(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_heredoc_end(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_hshptn(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_ident(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_if(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_if_mod(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_ifop(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_ignored_nl(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_ignored_sp(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_imaginary(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_in(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_int(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_ivar(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_kw(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_kwrest_param(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_label(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_label_end(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_lambda(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_lbrace(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_lbracket(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_lparen(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_magic_comment(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_massign(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_method_add_arg(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_method_add_block(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_mlhs_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_mlhs_add_post(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_mlhs_add_star(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_mlhs_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_mlhs_paren(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_module(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_mrhs_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_mrhs_add_star(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_mrhs_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_mrhs_new_from_args(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_next(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_nl(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_nokw_param(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_op(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_opassign(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_operator_ambiguous(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_param_error(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#168 + def on_params(_, _, _, _, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_paren(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_parse_error(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_period(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_program(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_qsymbols_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_qsymbols_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_qsymbols_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_qwords_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_qwords_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_qwords_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_rational(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_rbrace(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_rbracket(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_redo; end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_regexp_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_regexp_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_regexp_end(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_regexp_literal(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_regexp_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#166 + def on_rescue(_, _, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_rescue_mod(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_rest_param(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_retry; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_return(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_return0; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_rparen(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_sclass(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_semicolon(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_sp(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_stmts_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_stmts_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_string_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_string_concat(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_string_content; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_string_dvar(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_string_embexpr(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_string_literal(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_super(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_symbeg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_symbol(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_symbol_literal(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_symbols_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_symbols_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_symbols_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_tlambda(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_tlambeg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_top_const_field(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_top_const_ref(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_tstring_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_tstring_content(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_tstring_end(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_unary(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_undef(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_unless(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_unless_mod(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_until(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_until_mod(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_var_alias(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_var_field(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_var_ref(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_vcall(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_void_stmt; end + + # source://yarp//lib/yarp/ripper_compat.rb#165 + def on_when(_, _, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_while(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_while_mod(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_word_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_word_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_words_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_words_beg(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_words_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_words_sep(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#164 + def on_xstring_add(_, _); end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_xstring_literal(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_xstring_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#163 + def on_yield(_); end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_yield0; end + + # source://yarp//lib/yarp/ripper_compat.rb#162 + def on_zsuper; end + + # source://yarp//lib/yarp/ripper_compat.rb#158 + def result; end + + class << self + # This is a convenience method that runs the SexpBuilderPP subclass parser. + # + # source://yarp//lib/yarp/ripper_compat.rb#140 + def sexp(source); end + + # This is a convenience method that runs the SexpBuilder subclass parser. + # + # source://yarp//lib/yarp/ripper_compat.rb#135 + def sexp_raw(source); end + end +end + +# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that +# returns the arrays of [type, *children]. +# +# source://yarp//lib/yarp/ripper_compat.rb#16 +class YARP::RipperCompat::SexpBuilder < ::YARP::RipperCompat + private + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_BEGIN(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_CHAR(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_END(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on___end__(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_alias(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_alias_error(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_aref(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_aref_field(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_arg_ambiguous(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_arg_paren(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_args_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_args_add_block(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_args_add_star(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_args_forward(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_args_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_array(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_aryptn(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_assign(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_assign_error(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_assoc_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_assoc_splat(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_assoclist_from_args(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_backref(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_backtick(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_bare_assoc_hash(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_begin(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_binary(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_block_var(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_blockarg(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_bodystmt(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_brace_block(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_break(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_call(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_case(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_class(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_class_name_error(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_comma(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_command(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_command_call(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_comment(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_const(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_const_path_field(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_const_path_ref(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_const_ref(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_cvar(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_def(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_defined(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_defs(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_do_block(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_dot2(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_dot3(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_dyna_symbol(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_else(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_elsif(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_embdoc(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_embdoc_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_embdoc_end(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_embexpr_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_embexpr_end(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_embvar(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_ensure(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_excessed_comma(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_fcall(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_field(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_float(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_fndptn(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_for(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_gvar(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_hash(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_heredoc_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_heredoc_dedent(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_heredoc_end(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_hshptn(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_ident(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_if(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_if_mod(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_ifop(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_ignored_nl(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_ignored_sp(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_imaginary(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_in(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_int(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_ivar(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_kw(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_kwrest_param(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_label(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_label_end(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_lambda(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_lbrace(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_lbracket(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_lparen(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_magic_comment(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_massign(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_method_add_arg(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_method_add_block(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mlhs_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mlhs_add_post(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mlhs_add_star(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mlhs_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mlhs_paren(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_module(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mrhs_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mrhs_add_star(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mrhs_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_mrhs_new_from_args(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_next(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_nl(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_nokw_param(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_op(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_opassign(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_operator_ambiguous(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_param_error(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_params(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_paren(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_parse_error(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_period(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_program(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_qsymbols_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_qsymbols_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_qsymbols_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_qwords_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_qwords_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_qwords_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_rational(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_rbrace(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_rbracket(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_redo(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_regexp_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_regexp_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_regexp_end(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_regexp_literal(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_regexp_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_rescue(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_rescue_mod(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_rest_param(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_retry(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_return(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_return0(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_rparen(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_sclass(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_semicolon(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_sp(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_stmts_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_stmts_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_string_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_string_concat(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_string_content(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_string_dvar(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_string_embexpr(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_string_literal(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_super(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_symbeg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_symbol(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_symbol_literal(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_symbols_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_symbols_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_symbols_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_tlambda(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_tlambeg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_top_const_field(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_top_const_ref(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_tstring_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_tstring_content(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_tstring_end(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_unary(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_undef(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_unless(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_unless_mod(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_until(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_until_mod(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_var_alias(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_var_field(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_var_ref(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_vcall(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_void_stmt(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_when(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_while(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_while_mod(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_word_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_word_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_words_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_words_beg(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_words_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#26 + def on_words_sep(value); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_xstring_add(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_xstring_literal(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_xstring_new(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_yield(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_yield0(*args); end + + # source://yarp//lib/yarp/ripper_compat.rb#20 + def on_zsuper(*args); end +end + +# This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that +# returns the same values as ::Ripper::SexpBuilder except with a couple of +# niceties that flatten linked lists into arrays. +# +# source://yarp//lib/yarp/ripper_compat.rb#35 +class YARP::RipperCompat::SexpBuilderPP < ::YARP::RipperCompat::SexpBuilder + private + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def _dispatch_event_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def _dispatch_event_push(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_args_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_args_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_mlhs_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_mlhs_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_mrhs_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_mrhs_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_qsymbols_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_qsymbols_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_qwords_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_qwords_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_regexp_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_regexp_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_stmts_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_stmts_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_string_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_symbols_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_symbols_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_word_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_word_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_words_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_words_new; end + + # source://yarp//lib/yarp/ripper_compat.rb#42 + def on_xstring_add(list, item); end + + # source://yarp//lib/yarp/ripper_compat.rb#38 + def on_xstring_new; end +end + +# Represents the `self` keyword. +# +# self +# ^^^^ +# +# source://yarp//lib/yarp/node.rb#6857 +class YARP::SelfNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [SelfNode] a new instance of SelfNode + # + # source://yarp//lib/yarp/node.rb#6859 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6864 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6869 + def child_nodes; end + + # def copy: (**params) -> SelfNode + # + # source://yarp//lib/yarp/node.rb#6874 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6869 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6884 + def deconstruct_keys(keys); end +end + +# source://yarp//lib/yarp/serialize.rb#22 +module YARP::Serialize + class << self + # source://yarp//lib/yarp/serialize.rb#27 + def load(input, serialized); end + + # source://yarp//lib/yarp/serialize.rb#31 + def load_tokens(source, serialized); end + end +end + +# source://yarp//lib/yarp/serialize.rb#35 +class YARP::Serialize::Loader + # @return [Loader] a new instance of Loader + # + # source://yarp//lib/yarp/serialize.rb#39 + def initialize(source, serialized); end + + # Returns the value of attribute constant_pool. + # + # source://yarp//lib/yarp/serialize.rb#37 + def constant_pool; end + + # Returns the value of attribute constant_pool_offset. + # + # source://yarp//lib/yarp/serialize.rb#37 + def constant_pool_offset; end + + # Returns the value of attribute encoding. + # + # source://yarp//lib/yarp/serialize.rb#36 + def encoding; end + + # Returns the value of attribute input. + # + # source://yarp//lib/yarp/serialize.rb#36 + def input; end + + # Returns the value of attribute io. + # + # source://yarp//lib/yarp/serialize.rb#36 + def io; end + + # source://yarp//lib/yarp/serialize.rb#53 + def load_encoding; end + + # source://yarp//lib/yarp/serialize.rb#57 + def load_metadata; end + + # source://yarp//lib/yarp/serialize.rb#90 + def load_nodes; end + + # source://yarp//lib/yarp/serialize.rb#105 + def load_result; end + + # source://yarp//lib/yarp/serialize.rb#64 + def load_tokens; end + + # source://yarp//lib/yarp/serialize.rb#77 + def load_tokens_result; end + + # Returns the value of attribute serialized. + # + # source://yarp//lib/yarp/serialize.rb#36 + def serialized; end + + # Returns the value of attribute source. + # + # source://yarp//lib/yarp/serialize.rb#37 + def source; end + + private + + # source://yarp//lib/yarp/serialize.rb#162 + def load_constant; end + + # source://yarp//lib/yarp/serialize.rb#139 + def load_embedded_string; end + + # source://yarp//lib/yarp/serialize.rb#154 + def load_location; end + + # source://yarp//lib/yarp/serialize.rb#179 + def load_node; end + + # source://yarp//lib/yarp/serialize.rb#158 + def load_optional_location; end + + # source://yarp//lib/yarp/serialize.rb#132 + def load_optional_node; end + + # source://yarp//lib/yarp/serialize.rb#128 + def load_serialized_length; end + + # source://yarp//lib/yarp/serialize.rb#143 + def load_string; end + + # variable-length integer using https://en.wikipedia.org/wiki/LEB128 + # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints + # + # source://yarp//lib/yarp/serialize.rb#114 + def load_varint; end +end + +# source://yarp//lib/yarp/serialize.rb#23 +YARP::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer) + +# source://yarp//lib/yarp/serialize.rb#24 +YARP::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer) + +# source://yarp//lib/yarp/serialize.rb#25 +YARP::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer) + +# source://yarp//lib/yarp/serialize.rb#457 +YARP::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +# Represents a singleton class declaration involving the `class` keyword. +# +# class << self end +# ^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6893 +class YARP::SingletonClassNode < ::YARP::Node + # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void + # + # @return [SingletonClassNode] a new instance of SingletonClassNode + # + # source://yarp//lib/yarp/node.rb#6913 + def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6924 + def accept(visitor); end + + # attr_reader body: Node? + # + # source://yarp//lib/yarp/node.rb#6907 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6929 + def child_nodes; end + + # def class_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#6955 + def class_keyword; end + + # attr_reader class_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#6898 + def class_keyword_loc; end + + # def copy: (**params) -> SingletonClassNode + # + # source://yarp//lib/yarp/node.rb#6934 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6929 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#6950 + def deconstruct_keys(keys); end + + # def end_keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#6965 + def end_keyword; end + + # attr_reader end_keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#6910 + def end_keyword_loc; end + + # attr_reader expression: Node + # + # source://yarp//lib/yarp/node.rb#6904 + def expression; end + + # attr_reader locals: Array[Symbol] + # + # source://yarp//lib/yarp/node.rb#6895 + def locals; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#6960 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#6901 + def operator_loc; end +end + +# This represents a source of Ruby code that has been parsed. It is used in +# conjunction with locations to allow them to resolve line numbers and source +# ranges. +# +# source://yarp//lib/yarp.rb#7 +class YARP::Source + # @return [Source] a new instance of Source + # + # source://yarp//lib/yarp.rb#10 + def initialize(source, offsets = T.unsafe(nil)); end + + # source://yarp//lib/yarp.rb#23 + def column(value); end + + # source://yarp//lib/yarp.rb#19 + def line(value); end + + # Returns the value of attribute offsets. + # + # source://yarp//lib/yarp.rb#8 + def offsets; end + + # source://yarp//lib/yarp.rb#15 + def slice(offset, length); end + + # Returns the value of attribute source. + # + # source://yarp//lib/yarp.rb#8 + def source; end + + private + + # source://yarp//lib/yarp.rb#29 + def compute_offsets(code); end +end + +# Represents the use of the `__ENCODING__` keyword. +# +# __ENCODING__ +# ^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#6974 +class YARP::SourceEncodingNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [SourceEncodingNode] a new instance of SourceEncodingNode + # + # source://yarp//lib/yarp/node.rb#6976 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#6981 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6986 + def child_nodes; end + + # def copy: (**params) -> SourceEncodingNode + # + # source://yarp//lib/yarp/node.rb#6991 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#6986 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7001 + def deconstruct_keys(keys); end +end + +# Represents the use of the `__FILE__` keyword. +# +# __FILE__ +# ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7010 +class YARP::SourceFileNode < ::YARP::Node + # def initialize: (filepath: String, location: Location) -> void + # + # @return [SourceFileNode] a new instance of SourceFileNode + # + # source://yarp//lib/yarp/node.rb#7015 + def initialize(filepath, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7021 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7026 + def child_nodes; end + + # def copy: (**params) -> SourceFileNode + # + # source://yarp//lib/yarp/node.rb#7031 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7026 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7042 + def deconstruct_keys(keys); end + + # attr_reader filepath: String + # + # source://yarp//lib/yarp/node.rb#7012 + def filepath; end +end + +# Represents the use of the `__LINE__` keyword. +# +# __LINE__ +# ^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7051 +class YARP::SourceLineNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [SourceLineNode] a new instance of SourceLineNode + # + # source://yarp//lib/yarp/node.rb#7053 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7058 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7063 + def child_nodes; end + + # def copy: (**params) -> SourceLineNode + # + # source://yarp//lib/yarp/node.rb#7068 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7063 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7078 + def deconstruct_keys(keys); end +end + +# Represents the use of the splat operator. +# +# [*a] +# ^^ +# +# source://yarp//lib/yarp/node.rb#7087 +class YARP::SplatNode < ::YARP::Node + # def initialize: (operator_loc: Location, expression: Node?, location: Location) -> void + # + # @return [SplatNode] a new instance of SplatNode + # + # source://yarp//lib/yarp/node.rb#7095 + def initialize(operator_loc, expression, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7102 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7107 + def child_nodes; end + + # def copy: (**params) -> SplatNode + # + # source://yarp//lib/yarp/node.rb#7112 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7107 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7124 + def deconstruct_keys(keys); end + + # attr_reader expression: Node? + # + # source://yarp//lib/yarp/node.rb#7092 + def expression; end + + # def operator: () -> String + # + # source://yarp//lib/yarp/node.rb#7129 + def operator; end + + # attr_reader operator_loc: Location + # + # source://yarp//lib/yarp/node.rb#7089 + def operator_loc; end +end + +# Represents a set of statements contained within some scope. +# +# foo; bar; baz +# ^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7138 +class YARP::StatementsNode < ::YARP::Node + # def initialize: (body: Array[Node], location: Location) -> void + # + # @return [StatementsNode] a new instance of StatementsNode + # + # source://yarp//lib/yarp/node.rb#7143 + def initialize(body, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7149 + def accept(visitor); end + + # attr_reader body: Array[Node] + # + # source://yarp//lib/yarp/node.rb#7140 + def body; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7154 + def child_nodes; end + + # def copy: (**params) -> StatementsNode + # + # source://yarp//lib/yarp/node.rb#7159 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7154 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7170 + def deconstruct_keys(keys); end +end + +# Represents the use of compile-time string concatenation. +# +# "foo" "bar" +# ^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7179 +class YARP::StringConcatNode < ::YARP::Node + # def initialize: (left: Node, right: Node, location: Location) -> void + # + # @return [StringConcatNode] a new instance of StringConcatNode + # + # source://yarp//lib/yarp/node.rb#7187 + def initialize(left, right, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7194 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7199 + def child_nodes; end + + # def copy: (**params) -> StringConcatNode + # + # source://yarp//lib/yarp/node.rb#7204 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7199 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7216 + def deconstruct_keys(keys); end + + # attr_reader left: Node + # + # source://yarp//lib/yarp/node.rb#7181 + def left; end + + # attr_reader right: Node + # + # source://yarp//lib/yarp/node.rb#7184 + def right; end +end + +# Represents a string literal, a string contained within a `%w` list, or +# plain string content within an interpolated string. +# +# "foo" +# ^^^^^ +# +# %w[foo] +# ^^^ +# +# "foo #{bar} baz" +# ^^^^ ^^^^ +# +# source://yarp//lib/yarp/node.rb#7232 +class YARP::StringNode < ::YARP::Node + # def initialize: (opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> void + # + # @return [StringNode] a new instance of StringNode + # + # source://yarp//lib/yarp/node.rb#7246 + def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7255 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7260 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#7294 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7240 + def closing_loc; end + + # def content: () -> String + # + # source://yarp//lib/yarp/node.rb#7289 + def content; end + + # attr_reader content_loc: Location + # + # source://yarp//lib/yarp/node.rb#7237 + def content_loc; end + + # def copy: (**params) -> StringNode + # + # source://yarp//lib/yarp/node.rb#7265 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7260 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7279 + def deconstruct_keys(keys); end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#7284 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7234 + def opening_loc; end + + # attr_reader unescaped: String + # + # source://yarp//lib/yarp/node.rb#7243 + def unescaped; end +end + +# Represents the use of the `super` keyword with parentheses or arguments. +# +# super() +# ^^^^^^^ +# +# super foo, bar +# ^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7306 +class YARP::SuperNode < ::YARP::Node + # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode?, location: Location) -> void + # + # @return [SuperNode] a new instance of SuperNode + # + # source://yarp//lib/yarp/node.rb#7323 + def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7333 + def accept(visitor); end + + # attr_reader arguments: ArgumentsNode? + # + # source://yarp//lib/yarp/node.rb#7314 + def arguments; end + + # attr_reader block: BlockNode? + # + # source://yarp//lib/yarp/node.rb#7320 + def block; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7338 + def child_nodes; end + + # def copy: (**params) -> SuperNode + # + # source://yarp//lib/yarp/node.rb#7343 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7338 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7358 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#7363 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#7308 + def keyword_loc; end + + # def lparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#7368 + def lparen; end + + # attr_reader lparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7311 + def lparen_loc; end + + # def rparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#7373 + def rparen; end + + # attr_reader rparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7317 + def rparen_loc; end +end + +# Represents a symbol literal or a symbol contained within a `%i` list. +# +# :foo +# ^^^^ +# +# %i[foo] +# ^^^ +# +# source://yarp//lib/yarp/node.rb#7385 +class YARP::SymbolNode < ::YARP::Node + # def initialize: (opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void + # + # @return [SymbolNode] a new instance of SymbolNode + # + # source://yarp//lib/yarp/node.rb#7399 + def initialize(opening_loc, value_loc, closing_loc, unescaped, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7408 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7413 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#7447 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7393 + def closing_loc; end + + # def copy: (**params) -> SymbolNode + # + # source://yarp//lib/yarp/node.rb#7418 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7413 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7432 + def deconstruct_keys(keys); end + + # def opening: () -> String? + # + # source://yarp//lib/yarp/node.rb#7437 + def opening; end + + # attr_reader opening_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7387 + def opening_loc; end + + # attr_reader unescaped: String + # + # source://yarp//lib/yarp/node.rb#7396 + def unescaped; end + + # def value: () -> String? + # + # source://yarp//lib/yarp/node.rb#7442 + def value; end + + # attr_reader value_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7390 + def value_loc; end +end + +# This represents a token from the Ruby source. +# +# source://yarp//lib/yarp.rb#262 +class YARP::Token + # @return [Token] a new instance of Token + # + # source://yarp//lib/yarp.rb#265 + def initialize(type, value, location); end + + # source://yarp//lib/yarp.rb#289 + def ==(other); end + + # source://yarp//lib/yarp.rb#271 + def deconstruct_keys(keys); end + + # Returns the value of attribute location. + # + # source://yarp//lib/yarp.rb#263 + def location; end + + # source://yarp//lib/yarp.rb#275 + def pretty_print(q); end + + # Returns the value of attribute type. + # + # source://yarp//lib/yarp.rb#263 + def type; end + + # Returns the value of attribute value. + # + # source://yarp//lib/yarp.rb#263 + def value; end +end + +# Represents the use of the literal `true` keyword. +# +# true +# ^^^^ +# +# source://yarp//lib/yarp/node.rb#7456 +class YARP::TrueNode < ::YARP::Node + # def initialize: (location: Location) -> void + # + # @return [TrueNode] a new instance of TrueNode + # + # source://yarp//lib/yarp/node.rb#7458 + def initialize(location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7463 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7468 + def child_nodes; end + + # def copy: (**params) -> TrueNode + # + # source://yarp//lib/yarp/node.rb#7473 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7468 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7483 + def deconstruct_keys(keys); end +end + +# Represents the use of the `undef` keyword. +# +# undef :foo, :bar, :baz +# ^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7492 +class YARP::UndefNode < ::YARP::Node + # def initialize: (names: Array[Node], keyword_loc: Location, location: Location) -> void + # + # @return [UndefNode] a new instance of UndefNode + # + # source://yarp//lib/yarp/node.rb#7500 + def initialize(names, keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7507 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7512 + def child_nodes; end + + # def copy: (**params) -> UndefNode + # + # source://yarp//lib/yarp/node.rb#7517 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7512 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7529 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#7534 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#7497 + def keyword_loc; end + + # attr_reader names: Array[Node] + # + # source://yarp//lib/yarp/node.rb#7494 + def names; end +end + +# Represents the use of the `unless` keyword, either in the block form or the modifier form. +# +# bar unless foo +# ^^^^^^^^^^^^^^ +# +# unless foo then bar end +# ^^^^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7546 +class YARP::UnlessNode < ::YARP::Node + # def initialize: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void + # + # @return [UnlessNode] a new instance of UnlessNode + # + # source://yarp//lib/yarp/node.rb#7563 + def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7573 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7582 + def child_nodes; end + + # attr_reader consequent: ElseNode? + # + # source://yarp//lib/yarp/node.rb#7557 + def consequent; end + + # def copy: (**params) -> UnlessNode + # + # source://yarp//lib/yarp/node.rb#7587 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7582 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7602 + def deconstruct_keys(keys); end + + # def end_keyword: () -> String? + # + # source://yarp//lib/yarp/node.rb#7612 + def end_keyword; end + + # attr_reader end_keyword_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7560 + def end_keyword_loc; end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#7607 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#7548 + def keyword_loc; end + + # attr_reader predicate: Node + # + # source://yarp//lib/yarp/node.rb#7551 + def predicate; end + + # source://yarp//lib/yarp/node.rb#7577 + def set_newline_flag(newline_marked); end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#7554 + def statements; end +end + +# Represents the use of the `until` keyword, either in the block form or the modifier form. +# +# bar until foo +# ^^^^^^^^^^^^^ +# +# until foo do bar end +# ^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7624 +class YARP::UntilNode < ::YARP::Node + # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void + # + # @return [UntilNode] a new instance of UntilNode + # + # source://yarp//lib/yarp/node.rb#7641 + def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7651 + def accept(visitor); end + + # def begin_modifier?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#7695 + def begin_modifier?; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7660 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#7690 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7629 + def closing_loc; end + + # def copy: (**params) -> UntilNode + # + # source://yarp//lib/yarp/node.rb#7665 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7660 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7680 + def deconstruct_keys(keys); end + + # attr_reader flags: Integer + # + # source://yarp//lib/yarp/node.rb#7638 + def flags; end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#7685 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#7626 + def keyword_loc; end + + # attr_reader predicate: Node + # + # source://yarp//lib/yarp/node.rb#7632 + def predicate; end + + # source://yarp//lib/yarp/node.rb#7655 + def set_newline_flag(newline_marked); end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#7635 + def statements; end +end + +# The version constant is set by reading the result of calling yp_version. +YARP::VERSION = T.let(T.unsafe(nil), String) + +# source://yarp//lib/yarp.rb#192 +class YARP::Visitor < ::YARP::BasicVisitor + # Visit a AliasNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_alias_node(node); end + + # Visit a AlternationPatternNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_alternation_pattern_node(node); end + + # Visit a AndNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_and_node(node); end + + # Visit a ArgumentsNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_arguments_node(node); end + + # Visit a ArrayNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_array_node(node); end + + # Visit a ArrayPatternNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_array_pattern_node(node); end + + # Visit a AssocNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_assoc_node(node); end + + # Visit a AssocSplatNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_assoc_splat_node(node); end + + # Visit a BackReferenceReadNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_back_reference_read_node(node); end + + # Visit a BeginNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_begin_node(node); end + + # Visit a BlockArgumentNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_block_argument_node(node); end + + # Visit a BlockNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_block_node(node); end + + # Visit a BlockParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_block_parameter_node(node); end + + # Visit a BlockParametersNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_block_parameters_node(node); end + + # Visit a BreakNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_break_node(node); end + + # Visit a CallNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_call_node(node); end + + # Visit a CallOperatorAndWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_call_operator_and_write_node(node); end + + # Visit a CallOperatorOrWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_call_operator_or_write_node(node); end + + # Visit a CallOperatorWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_call_operator_write_node(node); end + + # Visit a CapturePatternNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_capture_pattern_node(node); end + + # Visit a CaseNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_case_node(node); end + + # Visit a ClassNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_class_node(node); end + + # Visit a ClassVariableAndWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_class_variable_and_write_node(node); end + + # Visit a ClassVariableOperatorWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_class_variable_operator_write_node(node); end + + # Visit a ClassVariableOrWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_class_variable_or_write_node(node); end + + # Visit a ClassVariableReadNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_class_variable_read_node(node); end + + # Visit a ClassVariableTargetNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_class_variable_target_node(node); end + + # Visit a ClassVariableWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_class_variable_write_node(node); end + + # Visit a ConstantAndWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_and_write_node(node); end + + # Visit a ConstantOperatorWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_operator_write_node(node); end + + # Visit a ConstantOrWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_or_write_node(node); end + + # Visit a ConstantPathAndWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_path_and_write_node(node); end + + # Visit a ConstantPathNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_path_node(node); end + + # Visit a ConstantPathOperatorWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_path_operator_write_node(node); end + + # Visit a ConstantPathOrWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_path_or_write_node(node); end + + # Visit a ConstantPathTargetNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_path_target_node(node); end + + # Visit a ConstantPathWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_path_write_node(node); end + + # Visit a ConstantReadNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_read_node(node); end + + # Visit a ConstantTargetNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_target_node(node); end + + # Visit a ConstantWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_constant_write_node(node); end + + # Visit a DefNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_def_node(node); end + + # Visit a DefinedNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_defined_node(node); end + + # Visit a ElseNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_else_node(node); end + + # Visit a EmbeddedStatementsNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_embedded_statements_node(node); end + + # Visit a EmbeddedVariableNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_embedded_variable_node(node); end + + # Visit a EnsureNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_ensure_node(node); end + + # Visit a FalseNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_false_node(node); end + + # Visit a FindPatternNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_find_pattern_node(node); end + + # Visit a FlipFlopNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_flip_flop_node(node); end + + # Visit a FloatNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_float_node(node); end + + # Visit a ForNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_for_node(node); end + + # Visit a ForwardingArgumentsNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_forwarding_arguments_node(node); end + + # Visit a ForwardingParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_forwarding_parameter_node(node); end + + # Visit a ForwardingSuperNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_forwarding_super_node(node); end + + # Visit a GlobalVariableAndWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_global_variable_and_write_node(node); end + + # Visit a GlobalVariableOperatorWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_global_variable_operator_write_node(node); end + + # Visit a GlobalVariableOrWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_global_variable_or_write_node(node); end + + # Visit a GlobalVariableReadNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_global_variable_read_node(node); end + + # Visit a GlobalVariableTargetNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_global_variable_target_node(node); end + + # Visit a GlobalVariableWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_global_variable_write_node(node); end + + # Visit a HashNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_hash_node(node); end + + # Visit a HashPatternNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_hash_pattern_node(node); end + + # Visit a IfNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_if_node(node); end + + # Visit a ImaginaryNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_imaginary_node(node); end + + # Visit a InNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_in_node(node); end + + # Visit a InstanceVariableAndWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_instance_variable_and_write_node(node); end + + # Visit a InstanceVariableOperatorWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_instance_variable_operator_write_node(node); end + + # Visit a InstanceVariableOrWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_instance_variable_or_write_node(node); end + + # Visit a InstanceVariableReadNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_instance_variable_read_node(node); end + + # Visit a InstanceVariableTargetNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_instance_variable_target_node(node); end + + # Visit a InstanceVariableWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_instance_variable_write_node(node); end + + # Visit a IntegerNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_integer_node(node); end + + # Visit a InterpolatedRegularExpressionNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_interpolated_regular_expression_node(node); end + + # Visit a InterpolatedStringNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_interpolated_string_node(node); end + + # Visit a InterpolatedSymbolNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_interpolated_symbol_node(node); end + + # Visit a InterpolatedXStringNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_interpolated_x_string_node(node); end + + # Visit a KeywordHashNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_keyword_hash_node(node); end + + # Visit a KeywordParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_keyword_parameter_node(node); end + + # Visit a KeywordRestParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_keyword_rest_parameter_node(node); end + + # Visit a LambdaNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_lambda_node(node); end + + # Visit a LocalVariableAndWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_local_variable_and_write_node(node); end + + # Visit a LocalVariableOperatorWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_local_variable_operator_write_node(node); end + + # Visit a LocalVariableOrWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_local_variable_or_write_node(node); end + + # Visit a LocalVariableReadNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_local_variable_read_node(node); end + + # Visit a LocalVariableTargetNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_local_variable_target_node(node); end + + # Visit a LocalVariableWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_local_variable_write_node(node); end + + # Visit a MatchPredicateNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_match_predicate_node(node); end + + # Visit a MatchRequiredNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_match_required_node(node); end + + # Visit a MissingNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_missing_node(node); end + + # Visit a ModuleNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_module_node(node); end + + # Visit a MultiWriteNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_multi_write_node(node); end + + # Visit a NextNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_next_node(node); end + + # Visit a NilNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_nil_node(node); end + + # Visit a NoKeywordsParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_no_keywords_parameter_node(node); end + + # Visit a NumberedReferenceReadNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_numbered_reference_read_node(node); end + + # Visit a OptionalParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_optional_parameter_node(node); end + + # Visit a OrNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_or_node(node); end + + # Visit a ParametersNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_parameters_node(node); end + + # Visit a ParenthesesNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_parentheses_node(node); end + + # Visit a PinnedExpressionNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_pinned_expression_node(node); end + + # Visit a PinnedVariableNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_pinned_variable_node(node); end + + # Visit a PostExecutionNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_post_execution_node(node); end + + # Visit a PreExecutionNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_pre_execution_node(node); end + + # Visit a ProgramNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_program_node(node); end + + # Visit a RangeNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_range_node(node); end + + # Visit a RationalNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_rational_node(node); end + + # Visit a RedoNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_redo_node(node); end + + # Visit a RegularExpressionNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_regular_expression_node(node); end + + # Visit a RequiredDestructuredParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_required_destructured_parameter_node(node); end + + # Visit a RequiredParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_required_parameter_node(node); end + + # Visit a RescueModifierNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_rescue_modifier_node(node); end + + # Visit a RescueNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_rescue_node(node); end + + # Visit a RestParameterNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_rest_parameter_node(node); end + + # Visit a RetryNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_retry_node(node); end + + # Visit a ReturnNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_return_node(node); end + + # Visit a SelfNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_self_node(node); end + + # Visit a SingletonClassNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_singleton_class_node(node); end + + # Visit a SourceEncodingNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_source_encoding_node(node); end + + # Visit a SourceFileNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_source_file_node(node); end + + # Visit a SourceLineNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_source_line_node(node); end + + # Visit a SplatNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_splat_node(node); end + + # Visit a StatementsNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_statements_node(node); end + + # Visit a StringConcatNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_string_concat_node(node); end + + # Visit a StringNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_string_node(node); end + + # Visit a SuperNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_super_node(node); end + + # Visit a SymbolNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_symbol_node(node); end + + # Visit a TrueNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_true_node(node); end + + # Visit a UndefNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_undef_node(node); end + + # Visit a UnlessNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_unless_node(node); end + + # Visit a UntilNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_until_node(node); end + + # Visit a WhenNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_when_node(node); end + + # Visit a WhileNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_while_node(node); end + + # Visit a XStringNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_x_string_node(node); end + + # Visit a YieldNode node + # + # source://yarp//lib/yarp.rb#187 + def visit_yield_node(node); end +end + +# Represents the use of the `when` keyword within a case statement. +# +# case true +# when true +# ^^^^^^^^^ +# end +# +# source://yarp//lib/yarp/node.rb#7706 +class YARP::WhenNode < ::YARP::Node + # def initialize: (keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location) -> void + # + # @return [WhenNode] a new instance of WhenNode + # + # source://yarp//lib/yarp/node.rb#7717 + def initialize(keyword_loc, conditions, statements, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7725 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7730 + def child_nodes; end + + # attr_reader conditions: Array[Node] + # + # source://yarp//lib/yarp/node.rb#7711 + def conditions; end + + # def copy: (**params) -> WhenNode + # + # source://yarp//lib/yarp/node.rb#7735 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7730 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7748 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#7753 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#7708 + def keyword_loc; end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#7714 + def statements; end +end + +# Represents the use of the `while` keyword, either in the block form or the modifier form. +# +# bar while foo +# ^^^^^^^^^^^^^ +# +# while foo do bar end +# ^^^^^^^^^^^^^^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7765 +class YARP::WhileNode < ::YARP::Node + # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void + # + # @return [WhileNode] a new instance of WhileNode + # + # source://yarp//lib/yarp/node.rb#7782 + def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7792 + def accept(visitor); end + + # def begin_modifier?: () -> bool + # + # @return [Boolean] + # + # source://yarp//lib/yarp/node.rb#7836 + def begin_modifier?; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7801 + def child_nodes; end + + # def closing: () -> String? + # + # source://yarp//lib/yarp/node.rb#7831 + def closing; end + + # attr_reader closing_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7770 + def closing_loc; end + + # def copy: (**params) -> WhileNode + # + # source://yarp//lib/yarp/node.rb#7806 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7801 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7821 + def deconstruct_keys(keys); end + + # attr_reader flags: Integer + # + # source://yarp//lib/yarp/node.rb#7779 + def flags; end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#7826 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#7767 + def keyword_loc; end + + # attr_reader predicate: Node + # + # source://yarp//lib/yarp/node.rb#7773 + def predicate; end + + # source://yarp//lib/yarp/node.rb#7796 + def set_newline_flag(newline_marked); end + + # attr_reader statements: StatementsNode? + # + # source://yarp//lib/yarp/node.rb#7776 + def statements; end +end + +# Represents an xstring literal with no interpolation. +# +# `foo` +# ^^^^^ +# +# source://yarp//lib/yarp/node.rb#7845 +class YARP::XStringNode < ::YARP::Node + # def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void + # + # @return [XStringNode] a new instance of XStringNode + # + # source://yarp//lib/yarp/node.rb#7859 + def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7868 + def accept(visitor); end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7873 + def child_nodes; end + + # def closing: () -> String + # + # source://yarp//lib/yarp/node.rb#7907 + def closing; end + + # attr_reader closing_loc: Location + # + # source://yarp//lib/yarp/node.rb#7853 + def closing_loc; end + + # def content: () -> String + # + # source://yarp//lib/yarp/node.rb#7902 + def content; end + + # attr_reader content_loc: Location + # + # source://yarp//lib/yarp/node.rb#7850 + def content_loc; end + + # def copy: (**params) -> XStringNode + # + # source://yarp//lib/yarp/node.rb#7878 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7873 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7892 + def deconstruct_keys(keys); end + + # def opening: () -> String + # + # source://yarp//lib/yarp/node.rb#7897 + def opening; end + + # attr_reader opening_loc: Location + # + # source://yarp//lib/yarp/node.rb#7847 + def opening_loc; end + + # attr_reader unescaped: String + # + # source://yarp//lib/yarp/node.rb#7856 + def unescaped; end +end + +# Represents the use of the `yield` keyword. +# +# yield 1 +# ^^^^^^^ +# +# source://yarp//lib/yarp/node.rb#7916 +class YARP::YieldNode < ::YARP::Node + # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location) -> void + # + # @return [YieldNode] a new instance of YieldNode + # + # source://yarp//lib/yarp/node.rb#7930 + def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location); end + + # def accept: (visitor: Visitor) -> void + # + # source://yarp//lib/yarp/node.rb#7939 + def accept(visitor); end + + # attr_reader arguments: ArgumentsNode? + # + # source://yarp//lib/yarp/node.rb#7924 + def arguments; end + + # def child_nodes: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7944 + def child_nodes; end + + # def copy: (**params) -> YieldNode + # + # source://yarp//lib/yarp/node.rb#7949 + def copy(**params); end + + # def child_nodes: () -> Array[nil | Node] + # def deconstruct: () -> Array[nil | Node] + # + # source://yarp//lib/yarp/node.rb#7944 + def deconstruct; end + + # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location] + # + # source://yarp//lib/yarp/node.rb#7963 + def deconstruct_keys(keys); end + + # def keyword: () -> String + # + # source://yarp//lib/yarp/node.rb#7968 + def keyword; end + + # attr_reader keyword_loc: Location + # + # source://yarp//lib/yarp/node.rb#7918 + def keyword_loc; end + + # def lparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#7973 + def lparen; end + + # attr_reader lparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7921 + def lparen_loc; end + + # def rparen: () -> String? + # + # source://yarp//lib/yarp/node.rb#7978 + def rparen; end + + # attr_reader rparen_loc: Location? + # + # source://yarp//lib/yarp/node.rb#7927 + def rparen_loc; end +end diff --git a/sorbet/rbi/shims/ast.rbi b/sorbet/rbi/shims/ast.rbi deleted file mode 100644 index 24095b67..00000000 --- a/sorbet/rbi/shims/ast.rbi +++ /dev/null @@ -1,5 +0,0 @@ -# typed: true - -class ::AST::Node - def location; end -end diff --git a/sorbet/rbi/shims/gems/yarp.rbi b/sorbet/rbi/shims/gems/yarp.rbi new file mode 100644 index 00000000..fdf0b0c8 --- /dev/null +++ b/sorbet/rbi/shims/gems/yarp.rbi @@ -0,0 +1,6856 @@ +# typed: strict + +=begin +This file is generated by the templates/template.rb script and should not be +modified manually. See templates/rbi/yarp.rbi.erb +if you are looking to modify the template +=end + +module YARP + class NodeInspector; end + + class Node + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + end + + # Represents the use of the `alias` keyword. + # + # alias foo bar + # ^^^^^^^^^^^^^ + class AliasNode < Node + sig { returns(Node) } + attr_reader :new_name + + sig { returns(Node) } + attr_reader :old_name + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { params(new_name: Node, old_name: Node, keyword_loc: Location, location: Location).void } + def initialize(new_name, old_name, keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(AliasNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an alternation pattern in pattern matching. + # + # foo => bar | baz + # ^^^^^^^^^ + class AlternationPatternNode < Node + sig { returns(Node) } + attr_reader :left + + sig { returns(Node) } + attr_reader :right + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(left: Node, right: Node, operator_loc: Location, location: Location).void } + def initialize(left, right, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(AlternationPatternNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&` operator or the `and` keyword. + # + # left and right + # ^^^^^^^^^^^^^^ + class AndNode < Node + sig { returns(Node) } + attr_reader :left + + sig { returns(Node) } + attr_reader :right + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(left: Node, right: Node, operator_loc: Location, location: Location).void } + def initialize(left, right, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(AndNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a set of arguments to a method or a keyword. + # + # return foo, bar, baz + # ^^^^^^^^^^^^^ + class ArgumentsNode < Node + sig { returns(T::Array[Node]) } + attr_reader :arguments + + sig { params(arguments: T::Array[Node], location: Location).void } + def initialize(arguments, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ArgumentsNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an array literal. This can be a regular array using brackets or + # a special array using % like %w or %i. + # + # [1, 2, 3] + # ^^^^^^^^^ + class ArrayNode < Node + sig { returns(T::Array[Node]) } + attr_reader :elements + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { params(elements: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } + def initialize(elements, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ArrayNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an array pattern in pattern matching. + # + # foo in 1, 2 + # ^^^^^^^^^^^ + # + # foo in [1, 2] + # ^^^^^^^^^^^^^ + # + # foo in *1 + # ^^^^^^^^^ + # + # foo in Bar[] + # ^^^^^^^^^^^^ + # + # foo in Bar[1, 2, 3] + # ^^^^^^^^^^^^^^^^^^^ + class ArrayPatternNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :constant + + sig { returns(T::Array[Node]) } + attr_reader :requireds + + sig { returns(T.nilable(Node)) } + attr_reader :rest + + sig { returns(T::Array[Node]) } + attr_reader :posts + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { params(constant: T.nilable(Node), requireds: T::Array[Node], rest: T.nilable(Node), posts: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } + def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ArrayPatternNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a hash key/value pair. + # + # { a => b } + # ^^^^^^ + class AssocNode < Node + sig { returns(Node) } + attr_reader :key + + sig { returns(T.nilable(Node)) } + attr_reader :value + + sig { returns(T.nilable(Location)) } + attr_reader :operator_loc + + sig { params(key: Node, value: T.nilable(Node), operator_loc: T.nilable(Location), location: Location).void } + def initialize(key, value, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(AssocNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a splat in a hash literal. + # + # { **foo } + # ^^^^^ + class AssocSplatNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :value + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(value: T.nilable(Node), operator_loc: Location, location: Location).void } + def initialize(value, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(AssocSplatNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents reading a reference to a field in the previous match. + # + # $' + # ^^ + class BackReferenceReadNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BackReferenceReadNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a begin statement. + # + # begin + # foo + # end + # ^^^^^ + class BeginNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :begin_keyword_loc + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(T.nilable(RescueNode)) } + attr_reader :rescue_clause + + sig { returns(T.nilable(ElseNode)) } + attr_reader :else_clause + + sig { returns(T.nilable(EnsureNode)) } + attr_reader :ensure_clause + + sig { returns(T.nilable(Location)) } + attr_reader :end_keyword_loc + + sig { params(begin_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), rescue_clause: T.nilable(RescueNode), else_clause: T.nilable(ElseNode), ensure_clause: T.nilable(EnsureNode), end_keyword_loc: T.nilable(Location), location: Location).void } + def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BeginNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def begin_keyword; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents block method arguments. + # + # bar(&args) + # ^^^^^^^^^^ + class BlockArgumentNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :expression + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(expression: T.nilable(Node), operator_loc: Location, location: Location).void } + def initialize(expression, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BlockArgumentNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a block local variable. + # + # a { |; b| } + # ^ + class BlockLocalVariableNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(name: Symbol, location: Location).void } + def initialize(name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BlockLocalVariableNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a block of ruby code. + # + # [1, 2, 3].each { |i| puts x } + # ^^^^^^^^^^^^^^ + class BlockNode < Node + sig { returns(T::Array[Symbol]) } + attr_reader :locals + + sig { returns(T.nilable(BlockParametersNode)) } + attr_reader :parameters + + sig { returns(T.nilable(Node)) } + attr_reader :body + + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(locals: T::Array[Symbol], parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).void } + def initialize(locals, parameters, body, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BlockNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a block parameter to a method, block, or lambda definition. + # + # def a(&b) + # ^^ + # end + class BlockParameterNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(name_loc: T.nilable(Location), operator_loc: Location, location: Location).void } + def initialize(name_loc, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BlockParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def name; end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a block's parameters declaration. + # + # -> (a, b = 1; local) { } + # ^^^^^^^^^^^^^^^^^ + # + # foo do |a, b = 1; local| + # ^^^^^^^^^^^^^^^^^ + # end + class BlockParametersNode < Node + sig { returns(T.nilable(ParametersNode)) } + attr_reader :parameters + + sig { returns(T::Array[Node]) } + attr_reader :locals + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { params(parameters: T.nilable(ParametersNode), locals: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } + def initialize(parameters, locals, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BlockParametersNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `break` keyword. + # + # break foo + # ^^^^^^^^^ + class BreakNode < Node + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).void } + def initialize(arguments, keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(BreakNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&=` operator on a call. + # + # foo.bar &&= value + # ^^^^^^^^^^^^^^^^^ + class CallAndWriteNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :receiver + + sig { returns(T.nilable(Location)) } + attr_reader :call_operator_loc + + sig { returns(T.nilable(Location)) } + attr_reader :message_loc + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(Integer) } + attr_reader :flags + + sig { returns(String) } + attr_reader :read_name + + sig { returns(String) } + attr_reader :write_name + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location).void } + def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(CallAndWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { returns(T::Boolean) } + def variable_call?; end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a method call, in all of the various forms that can take. + # + # foo + # ^^^ + # + # foo() + # ^^^^^ + # + # +foo + # ^^^^ + # + # foo + bar + # ^^^^^^^^^ + # + # foo.bar + # ^^^^^^^ + # + # foo&.bar + # ^^^^^^^^ + class CallNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :receiver + + sig { returns(T.nilable(Location)) } + attr_reader :call_operator_loc + + sig { returns(T.nilable(Location)) } + attr_reader :message_loc + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(T.nilable(BlockNode)) } + attr_reader :block + + sig { returns(Integer) } + attr_reader :flags + + sig { returns(String) } + attr_reader :name + + sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), block: T.nilable(BlockNode), flags: Integer, name: String, location: Location).void } + def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(CallNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { returns(T::Boolean) } + def variable_call?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of an assignment operator on a call. + # + # foo.bar += baz + # ^^^^^^^^^^^^^^ + class CallOperatorWriteNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :receiver + + sig { returns(T.nilable(Location)) } + attr_reader :call_operator_loc + + sig { returns(T.nilable(Location)) } + attr_reader :message_loc + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(Integer) } + attr_reader :flags + + sig { returns(String) } + attr_reader :read_name + + sig { returns(String) } + attr_reader :write_name + + sig { returns(Symbol) } + attr_reader :operator + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(target: T.nilable(Node), operator_loc: T.nilable(Location), value: Node, operator: Symbol, location: Location).void } + def initialize(target, operator_loc, value, operator, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(CallOperatorWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { returns(T::Boolean) } + def variable_call?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||=` operator on a call. + # + # foo.bar ||= value + # ^^^^^^^^^^^^^^^^^ + class CallOrWriteNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :receiver + + sig { returns(T.nilable(Location)) } + attr_reader :call_operator_loc + + sig { returns(T.nilable(Location)) } + attr_reader :message_loc + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(Integer) } + attr_reader :flags + + sig { returns(String) } + attr_reader :read_name + + sig { returns(String) } + attr_reader :write_name + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location).void } + def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(CallOrWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { returns(T::Boolean) } + def variable_call?; end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents assigning to a local variable in pattern matching. + # + # foo => [bar => baz] + # ^^^^^^^^^^^^ + class CapturePatternNode < Node + sig { returns(Node) } + attr_reader :value + + sig { returns(Node) } + attr_reader :target + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(value: Node, target: Node, operator_loc: Location, location: Location).void } + def initialize(value, target, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(CapturePatternNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of a case statement. + # + # case true + # ^^^^^^^^^ + # when false + # end + class CaseNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :predicate + + sig { returns(T::Array[Node]) } + attr_reader :conditions + + sig { returns(T.nilable(ElseNode)) } + attr_reader :consequent + + sig { returns(Location) } + attr_reader :case_keyword_loc + + sig { returns(Location) } + attr_reader :end_keyword_loc + + sig { params(predicate: T.nilable(Node), conditions: T::Array[Node], consequent: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location, location: Location).void } + def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(CaseNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def case_keyword; end + + sig { returns(String) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a class declaration involving the `class` keyword. + # + # class Foo end + # ^^^^^^^^^^^^^ + class ClassNode < Node + sig { returns(T::Array[Symbol]) } + attr_reader :locals + + sig { returns(Location) } + attr_reader :class_keyword_loc + + sig { returns(Node) } + attr_reader :constant_path + + sig { returns(T.nilable(Location)) } + attr_reader :inheritance_operator_loc + + sig { returns(T.nilable(Node)) } + attr_reader :superclass + + sig { returns(T.nilable(Node)) } + attr_reader :body + + sig { returns(Location) } + attr_reader :end_keyword_loc + + sig { returns(String) } + attr_reader :name + + sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: T.nilable(Location), superclass: T.nilable(Node), body: T.nilable(Node), end_keyword_loc: Location, name: String, location: Location).void } + def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ClassNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def class_keyword; end + + sig { returns(T.nilable(String)) } + def inheritance_operator; end + + sig { returns(String) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&=` operator for assignment to a class variable. + # + # @@target &&= value + # ^^^^^^^^^^^^^^^^ + class ClassVariableAndWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name, name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ClassVariableAndWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents assigning to a class variable using an operator that isn't `=`. + # + # @@target += value + # ^^^^^^^^^^^^^^^^^ + class ClassVariableOperatorWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :operator + + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } + def initialize(name, name_loc, operator_loc, value, operator, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ClassVariableOperatorWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||=` operator for assignment to a class variable. + # + # @@target ||= value + # ^^^^^^^^^^^^^^^^^^ + class ClassVariableOrWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name, name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ClassVariableOrWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents referencing a class variable. + # + # @@foo + # ^^^^^ + class ClassVariableReadNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(name: Symbol, location: Location).void } + def initialize(name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ClassVariableReadNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a class variable in a context that doesn't have an explicit value. + # + # @@foo, @@bar = baz + # ^^^^^ ^^^^^ + class ClassVariableTargetNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(name: Symbol, location: Location).void } + def initialize(name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ClassVariableTargetNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a class variable. + # + # @@foo = 1 + # ^^^^^^^^^ + class ClassVariableWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(T.nilable(Location)) } + attr_reader :operator_loc + + sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: T.nilable(Location), location: Location).void } + def initialize(name, name_loc, value, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ClassVariableWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&=` operator for assignment to a constant. + # + # Target &&= value + # ^^^^^^^^^^^^^^^^ + class ConstantAndWriteNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantAndWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def name; end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents assigning to a constant using an operator that isn't `=`. + # + # Target += value + # ^^^^^^^^^^^^^^^ + class ConstantOperatorWriteNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :operator + + sig { params(name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } + def initialize(name_loc, operator_loc, value, operator, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantOperatorWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def name; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||=` operator for assignment to a constant. + # + # Target ||= value + # ^^^^^^^^^^^^^^^^ + class ConstantOrWriteNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantOrWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def name; end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&=` operator for assignment to a constant path. + # + # Parent::Child &&= value + # ^^^^^^^^^^^^^^^^^^^^^^^ + class ConstantPathAndWriteNode < Node + sig { returns(ConstantPathNode) } + attr_reader :target + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).void } + def initialize(target, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantPathAndWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents accessing a constant through a path of `::` operators. + # + # Foo::Bar + # ^^^^^^^^ + class ConstantPathNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :parent + + sig { returns(Node) } + attr_reader :child + + sig { returns(Location) } + attr_reader :delimiter_loc + + sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).void } + def initialize(parent, child, delimiter_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantPathNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def delimiter; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents assigning to a constant path using an operator that isn't `=`. + # + # Parent::Child += value + # ^^^^^^^^^^^^^^^^^^^^^^ + class ConstantPathOperatorWriteNode < Node + sig { returns(ConstantPathNode) } + attr_reader :target + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :operator + + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } + def initialize(target, operator_loc, value, operator, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantPathOperatorWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||=` operator for assignment to a constant path. + # + # Parent::Child ||= value + # ^^^^^^^^^^^^^^^^^^^^^^^ + class ConstantPathOrWriteNode < Node + sig { returns(ConstantPathNode) } + attr_reader :target + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).void } + def initialize(target, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantPathOrWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a constant path in a context that doesn't have an explicit value. + # + # Foo::Foo, Bar::Bar = baz + # ^^^^^^^^ ^^^^^^^^ + class ConstantPathTargetNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :parent + + sig { returns(Node) } + attr_reader :child + + sig { returns(Location) } + attr_reader :delimiter_loc + + sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).void } + def initialize(parent, child, delimiter_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantPathTargetNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def delimiter; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a constant path. + # + # ::Foo = 1 + # ^^^^^^^^^ + # + # Foo::Bar = 1 + # ^^^^^^^^^^^^ + # + # ::Foo::Bar = 1 + # ^^^^^^^^^^^^^^ + class ConstantPathWriteNode < Node + sig { returns(ConstantPathNode) } + attr_reader :target + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).void } + def initialize(target, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantPathWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents referencing a constant. + # + # Foo + # ^^^ + class ConstantReadNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantReadNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a constant in a context that doesn't have an explicit value. + # + # Foo, Bar = baz + # ^^^ ^^^ + class ConstantTargetNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantTargetNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a constant. + # + # Foo = 1 + # ^^^^^^^ + class ConstantWriteNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(name_loc: Location, value: Node, operator_loc: Location, location: Location).void } + def initialize(name_loc, value, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ConstantWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def name; end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a method definition. + # + # def method + # end + # ^^^^^^^^^^ + class DefNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(T.nilable(Node)) } + attr_reader :receiver + + sig { returns(T.nilable(ParametersNode)) } + attr_reader :parameters + + sig { returns(T.nilable(Node)) } + attr_reader :body + + sig { returns(T::Array[Symbol]) } + attr_reader :locals + + sig { returns(Location) } + attr_reader :def_keyword_loc + + sig { returns(T.nilable(Location)) } + attr_reader :operator_loc + + sig { returns(T.nilable(Location)) } + attr_reader :lparen_loc + + sig { returns(T.nilable(Location)) } + attr_reader :rparen_loc + + sig { returns(T.nilable(Location)) } + attr_reader :equal_loc + + sig { returns(T.nilable(Location)) } + attr_reader :end_keyword_loc + + sig { params(name_loc: Location, receiver: T.nilable(Node), parameters: T.nilable(ParametersNode), body: T.nilable(Node), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: T.nilable(Location), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), equal_loc: T.nilable(Location), end_keyword_loc: T.nilable(Location), location: Location).void } + def initialize(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(DefNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def name; end + + sig { returns(String) } + def def_keyword; end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(T.nilable(String)) } + def equal; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `defined?` keyword. + # + # defined?(a) + # ^^^^^^^^^^^ + class DefinedNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :lparen_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(T.nilable(Location)) } + attr_reader :rparen_loc + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { params(lparen_loc: T.nilable(Location), value: Node, rparen_loc: T.nilable(Location), keyword_loc: Location, location: Location).void } + def initialize(lparen_loc, value, rparen_loc, keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(DefinedNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an `else` clause in a `case`, `if`, or `unless` statement. + # + # if a then b else c end + # ^^^^^^^^^^ + class ElseNode < Node + sig { returns(Location) } + attr_reader :else_keyword_loc + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(T.nilable(Location)) } + attr_reader :end_keyword_loc + + sig { params(else_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: T.nilable(Location), location: Location).void } + def initialize(else_keyword_loc, statements, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ElseNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def else_keyword; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an interpolated set of statements. + # + # "foo #{bar}" + # ^^^^^^ + class EmbeddedStatementsNode < Node + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(opening_loc: Location, statements: T.nilable(StatementsNode), closing_loc: Location, location: Location).void } + def initialize(opening_loc, statements, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(EmbeddedStatementsNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an interpolated variable. + # + # "foo #@bar" + # ^^^^^ + class EmbeddedVariableNode < Node + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :variable + + sig { params(operator_loc: Location, variable: Node, location: Location).void } + def initialize(operator_loc, variable, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(EmbeddedVariableNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an `ensure` clause in a `begin` statement. + # + # begin + # foo + # ensure + # ^^^^^^ + # bar + # end + class EnsureNode < Node + sig { returns(Location) } + attr_reader :ensure_keyword_loc + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Location) } + attr_reader :end_keyword_loc + + sig { params(ensure_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: Location, location: Location).void } + def initialize(ensure_keyword_loc, statements, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(EnsureNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def ensure_keyword; end + + sig { returns(String) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the literal `false` keyword. + # + # false + # ^^^^^ + class FalseNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(FalseNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a find pattern in pattern matching. + # + # foo in *bar, baz, *qux + # ^^^^^^^^^^^^^^^^^^^^^^ + # + # foo in [*bar, baz, *qux] + # ^^^^^^^^^^^^^^^^^^^^^^^^ + # + # foo in Foo(*bar, baz, *qux) + # ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + class FindPatternNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :constant + + sig { returns(Node) } + attr_reader :left + + sig { returns(T::Array[Node]) } + attr_reader :requireds + + sig { returns(Node) } + attr_reader :right + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { params(constant: T.nilable(Node), left: Node, requireds: T::Array[Node], right: Node, opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } + def initialize(constant, left, requireds, right, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(FindPatternNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `..` or `...` operators to create flip flops. + # + # baz if foo .. bar + # ^^^^^^^^^^ + class FlipFlopNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :left + + sig { returns(T.nilable(Node)) } + attr_reader :right + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Integer) } + attr_reader :flags + + sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).void } + def initialize(left, right, operator_loc, flags, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(FlipFlopNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { returns(T::Boolean) } + def exclude_end?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a floating point number literal. + # + # 1.0 + # ^^^ + class FloatNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(FloatNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `for` keyword. + # + # for i in a end + # ^^^^^^^^^^^^^^ + class ForNode < Node + sig { returns(Node) } + attr_reader :index + + sig { returns(Node) } + attr_reader :collection + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Location) } + attr_reader :for_keyword_loc + + sig { returns(Location) } + attr_reader :in_keyword_loc + + sig { returns(T.nilable(Location)) } + attr_reader :do_keyword_loc + + sig { returns(Location) } + attr_reader :end_keyword_loc + + sig { params(index: Node, collection: Node, statements: T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: T.nilable(Location), end_keyword_loc: Location, location: Location).void } + def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ForNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def for_keyword; end + + sig { returns(String) } + def in_keyword; end + + sig { returns(T.nilable(String)) } + def do_keyword; end + + sig { returns(String) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents forwarding all arguments to this method to another method. + # + # def foo(...) + # bar(...) + # ^^^^^^^^ + # end + class ForwardingArgumentsNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ForwardingArgumentsNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the forwarding parameter in a method, block, or lambda declaration. + # + # def foo(...) + # ^^^ + # end + class ForwardingParameterNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ForwardingParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `super` keyword without parentheses or arguments. + # + # super + # ^^^^^ + class ForwardingSuperNode < Node + sig { returns(T.nilable(BlockNode)) } + attr_reader :block + + sig { params(block: T.nilable(BlockNode), location: Location).void } + def initialize(block, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ForwardingSuperNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&=` operator for assignment to a global variable. + # + # $target &&= value + # ^^^^^^^^^^^^^^^^^ + class GlobalVariableAndWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(GlobalVariableAndWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents assigning to a global variable using an operator that isn't `=`. + # + # $target += value + # ^^^^^^^^^^^^^^^^ + class GlobalVariableOperatorWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :operator + + sig { params(name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } + def initialize(name_loc, operator_loc, value, operator, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(GlobalVariableOperatorWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||=` operator for assignment to a global variable. + # + # $target ||= value + # ^^^^^^^^^^^^^^^^^ + class GlobalVariableOrWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(GlobalVariableOrWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents referencing a global variable. + # + # $foo + # ^^^^ + class GlobalVariableReadNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(GlobalVariableReadNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a global variable in a context that doesn't have an explicit value. + # + # $foo, $bar = baz + # ^^^^ ^^^^ + class GlobalVariableTargetNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(GlobalVariableTargetNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a global variable. + # + # $foo = 1 + # ^^^^^^^^ + class GlobalVariableWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(name_loc: Location, value: Node, operator_loc: Location, location: Location).void } + def initialize(name_loc, value, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(GlobalVariableWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a hash literal. + # + # { a => b } + # ^^^^^^^^^^ + class HashNode < Node + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(T::Array[Node]) } + attr_reader :elements + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(opening_loc: Location, elements: T::Array[Node], closing_loc: Location, location: Location).void } + def initialize(opening_loc, elements, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(HashNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a hash pattern in pattern matching. + # + # foo => { a: 1, b: 2 } + # ^^^^^^^^^^^^^^ + # + # foo => { a: 1, b: 2, **c } + # ^^^^^^^^^^^^^^^^^^^ + class HashPatternNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :constant + + sig { returns(T::Array[Node]) } + attr_reader :assocs + + sig { returns(T.nilable(Node)) } + attr_reader :kwrest + + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { params(constant: T.nilable(Node), assocs: T::Array[Node], kwrest: T.nilable(Node), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).void } + def initialize(constant, assocs, kwrest, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(HashPatternNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `if` keyword, either in the block form or the modifier form. + # + # bar if foo + # ^^^^^^^^^^ + # + # if foo then bar end + # ^^^^^^^^^^^^^^^^^^^ + class IfNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :if_keyword_loc + + sig { returns(Node) } + attr_reader :predicate + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(T.nilable(Node)) } + attr_reader :consequent + + sig { returns(T.nilable(Location)) } + attr_reader :end_keyword_loc + + sig { params(if_keyword_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(Node), end_keyword_loc: T.nilable(Location), location: Location).void } + def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(IfNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def if_keyword; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an imaginary number literal. + # + # 1.0i + # ^^^^ + class ImaginaryNode < Node + sig { returns(Node) } + attr_reader :numeric + + sig { params(numeric: Node, location: Location).void } + def initialize(numeric, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ImaginaryNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `in` keyword in a case statement. + # + # case a; in b then c end + # ^^^^^^^^^^^ + class InNode < Node + sig { returns(Node) } + attr_reader :pattern + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Location) } + attr_reader :in_loc + + sig { returns(T.nilable(Location)) } + attr_reader :then_loc + + sig { params(pattern: Node, statements: T.nilable(StatementsNode), in_loc: Location, then_loc: T.nilable(Location), location: Location).void } + def initialize(pattern, statements, in_loc, then_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def in; end + + sig { returns(T.nilable(String)) } + def then; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&=` operator for assignment to an instance variable. + # + # @target &&= value + # ^^^^^^^^^^^^^^^^^ + class InstanceVariableAndWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name, name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InstanceVariableAndWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents assigning to an instance variable using an operator that isn't `=`. + # + # @target += value + # ^^^^^^^^^^^^^^^^ + class InstanceVariableOperatorWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :operator + + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).void } + def initialize(name, name_loc, operator_loc, value, operator, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InstanceVariableOperatorWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||=` operator for assignment to an instance variable. + # + # @target ||= value + # ^^^^^^^^^^^^^^^^^ + class InstanceVariableOrWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name, name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InstanceVariableOrWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents referencing an instance variable. + # + # @foo + # ^^^^ + class InstanceVariableReadNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(name: Symbol, location: Location).void } + def initialize(name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InstanceVariableReadNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to an instance variable in a context that doesn't have an explicit value. + # + # @foo, @bar = baz + # ^^^^ ^^^^ + class InstanceVariableTargetNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(name: Symbol, location: Location).void } + def initialize(name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InstanceVariableTargetNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to an instance variable. + # + # @foo = 1 + # ^^^^^^^^ + class InstanceVariableWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).void } + def initialize(name, name_loc, value, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InstanceVariableWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an integer number literal. + # + # 1 + # ^ + class IntegerNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(IntegerNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a regular expression literal that contains interpolation. + # + # /foo #{bar} baz/ + # ^^^^^^^^^^^^^^^^ + class InterpolatedRegularExpressionNode < Node + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(T::Array[Node]) } + attr_reader :parts + + sig { returns(Location) } + attr_reader :closing_loc + + sig { returns(Integer) } + attr_reader :flags + + sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, flags: Integer, location: Location).void } + def initialize(opening_loc, parts, closing_loc, flags, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InterpolatedRegularExpressionNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { returns(T::Boolean) } + def ignore_case?; end + + sig { returns(T::Boolean) } + def multi_line?; end + + sig { returns(T::Boolean) } + def extended?; end + + sig { returns(T::Boolean) } + def euc_jp?; end + + sig { returns(T::Boolean) } + def ascii_8bit?; end + + sig { returns(T::Boolean) } + def windows_31j?; end + + sig { returns(T::Boolean) } + def utf_8?; end + + sig { returns(T::Boolean) } + def once?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a string literal that contains interpolation. + # + # "foo #{bar} baz" + # ^^^^^^^^^^^^^^^^ + class InterpolatedStringNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T::Array[Node]) } + attr_reader :parts + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).void } + def initialize(opening_loc, parts, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InterpolatedStringNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a symbol literal that contains interpolation. + # + # :"foo #{bar} baz" + # ^^^^^^^^^^^^^^^^^ + class InterpolatedSymbolNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T::Array[Node]) } + attr_reader :parts + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).void } + def initialize(opening_loc, parts, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InterpolatedSymbolNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an xstring literal that contains interpolation. + # + # `foo #{bar} baz` + # ^^^^^^^^^^^^^^^^ + class InterpolatedXStringNode < Node + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(T::Array[Node]) } + attr_reader :parts + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, location: Location).void } + def initialize(opening_loc, parts, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(InterpolatedXStringNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a hash literal without opening and closing braces. + # + # foo(a: b) + # ^^^^ + class KeywordHashNode < Node + sig { returns(T::Array[Node]) } + attr_reader :elements + + sig { params(elements: T::Array[Node], location: Location).void } + def initialize(elements, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(KeywordHashNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a keyword parameter to a method, block, or lambda definition. + # + # def a(b:) + # ^^ + # end + # + # def a(b: 1) + # ^^^^ + # end + class KeywordParameterNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(T.nilable(Node)) } + attr_reader :value + + sig { params(name_loc: Location, value: T.nilable(Node), location: Location).void } + def initialize(name_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(KeywordParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def name; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a keyword rest parameter to a method, block, or lambda definition. + # + # def a(**b) + # ^^^ + # end + class KeywordRestParameterNode < Node + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(T.nilable(Location)) } + attr_reader :name_loc + + sig { params(operator_loc: Location, name_loc: T.nilable(Location), location: Location).void } + def initialize(operator_loc, name_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(KeywordRestParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { returns(T.nilable(String)) } + def name; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents using a lambda literal (not the lambda method call). + # + # ->(value) { value * 2 } + # ^^^^^^^^^^^^^^^^^^^^^^^ + class LambdaNode < Node + sig { returns(T::Array[Symbol]) } + attr_reader :locals + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { returns(T.nilable(BlockParametersNode)) } + attr_reader :parameters + + sig { returns(T.nilable(Node)) } + attr_reader :body + + sig { params(locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), location: Location).void } + def initialize(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(LambdaNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `&&=` operator for assignment to a local variable. + # + # target &&= value + # ^^^^^^^^^^^^^^^^ + class LocalVariableAndWriteNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Integer) } + attr_reader :depth + + sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).void } + def initialize(name_loc, operator_loc, value, name, depth, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(LocalVariableAndWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents assigning to a local variable using an operator that isn't `=`. + # + # target += value + # ^^^^^^^^^^^^^^^ + class LocalVariableOperatorWriteNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Symbol) } + attr_reader :operator + + sig { returns(Integer) } + attr_reader :depth + + sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location).void } + def initialize(name_loc, operator_loc, value, name, operator, depth, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(LocalVariableOperatorWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||=` operator for assignment to a local variable. + # + # target ||= value + # ^^^^^^^^^^^^^^^^ + class LocalVariableOrWriteNode < Node + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Integer) } + attr_reader :depth + + sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).void } + def initialize(name_loc, operator_loc, value, name, depth, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(LocalVariableOrWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents reading a local variable. Note that this requires that a local + # variable of the same name has already been written to in the same scope, + # otherwise it is parsed as a method call. + # + # foo + # ^^^ + class LocalVariableReadNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Integer) } + attr_reader :depth + + sig { params(name: Symbol, depth: Integer, location: Location).void } + def initialize(name, depth, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(LocalVariableReadNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a local variable in a context that doesn't have an explicit value. + # + # foo, bar = baz + # ^^^ ^^^ + class LocalVariableTargetNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Integer) } + attr_reader :depth + + sig { params(name: Symbol, depth: Integer, location: Location).void } + def initialize(name, depth, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(LocalVariableTargetNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents writing to a local variable. + # + # foo = 1 + # ^^^^^^^ + class LocalVariableWriteNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Integer) } + attr_reader :depth + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Node) } + attr_reader :value + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location).void } + def initialize(name, depth, name_loc, value, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(LocalVariableWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the modifier `in` operator. + # + # foo in bar + # ^^^^^^^^^^ + class MatchPredicateNode < Node + sig { returns(Node) } + attr_reader :value + + sig { returns(Node) } + attr_reader :pattern + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).void } + def initialize(value, pattern, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(MatchPredicateNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `=>` operator. + # + # foo => bar + # ^^^^^^^^^^ + class MatchRequiredNode < Node + sig { returns(Node) } + attr_reader :value + + sig { returns(Node) } + attr_reader :pattern + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).void } + def initialize(value, pattern, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(MatchRequiredNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a node that is missing from the source and results in a syntax + # error. + class MissingNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(MissingNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a module declaration involving the `module` keyword. + # + # module Foo end + # ^^^^^^^^^^^^^^ + class ModuleNode < Node + sig { returns(T::Array[Symbol]) } + attr_reader :locals + + sig { returns(Location) } + attr_reader :module_keyword_loc + + sig { returns(Node) } + attr_reader :constant_path + + sig { returns(T.nilable(Node)) } + attr_reader :body + + sig { returns(Location) } + attr_reader :end_keyword_loc + + sig { returns(String) } + attr_reader :name + + sig { params(locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: T.nilable(Node), end_keyword_loc: Location, name: String, location: Location).void } + def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ModuleNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def module_keyword; end + + sig { returns(String) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a multi-target expression. + # + # a, b, c = 1, 2, 3 + # ^^^^^^^^^^^^^^^^^ + class MultiWriteNode < Node + sig { returns(T::Array[Node]) } + attr_reader :targets + + sig { returns(T.nilable(Location)) } + attr_reader :operator_loc + + sig { returns(T.nilable(Node)) } + attr_reader :value + + sig { returns(T.nilable(Location)) } + attr_reader :lparen_loc + + sig { returns(T.nilable(Location)) } + attr_reader :rparen_loc + + sig { params(targets: T::Array[Node], operator_loc: T.nilable(Location), value: T.nilable(Node), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), location: Location).void } + def initialize(targets, operator_loc, value, lparen_loc, rparen_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(MultiWriteNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `next` keyword. + # + # next 1 + # ^^^^^^ + class NextNode < Node + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).void } + def initialize(arguments, keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(NextNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `nil` keyword. + # + # nil + # ^^^ + class NilNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(NilNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of `**nil` inside method arguments. + # + # def a(**nil) + # ^^^^^ + # end + class NoKeywordsParameterNode < Node + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { params(operator_loc: Location, keyword_loc: Location, location: Location).void } + def initialize(operator_loc, keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(NoKeywordsParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents reading a numbered reference to a capture in the previous match. + # + # $1 + # ^^ + class NumberedReferenceReadNode < Node + sig { returns(Integer) } + attr_reader :number + + sig { params(number: Integer, location: Location).void } + def initialize(number, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(NumberedReferenceReadNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an optional parameter to a method, block, or lambda definition. + # + # def a(b = 1) + # ^^^^^ + # end + class OptionalParameterNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { returns(Location) } + attr_reader :name_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :value + + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).void } + def initialize(name, name_loc, operator_loc, value, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(OptionalParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `||` operator or the `or` keyword. + # + # left or right + # ^^^^^^^^^^^^^ + class OrNode < Node + sig { returns(Node) } + attr_reader :left + + sig { returns(Node) } + attr_reader :right + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(left: Node, right: Node, operator_loc: Location, location: Location).void } + def initialize(left, right, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(OrNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the list of parameters on a method, block, or lambda definition. + # + # def a(b, c, d) + # ^^^^^^^ + # end + class ParametersNode < Node + sig { returns(T::Array[Node]) } + attr_reader :requireds + + sig { returns(T::Array[Node]) } + attr_reader :optionals + + sig { returns(T::Array[Node]) } + attr_reader :posts + + sig { returns(T.nilable(RestParameterNode)) } + attr_reader :rest + + sig { returns(T::Array[Node]) } + attr_reader :keywords + + sig { returns(T.nilable(Node)) } + attr_reader :keyword_rest + + sig { returns(T.nilable(BlockParameterNode)) } + attr_reader :block + + sig { params(requireds: T::Array[Node], optionals: T::Array[Node], posts: T::Array[Node], rest: T.nilable(RestParameterNode), keywords: T::Array[Node], keyword_rest: T.nilable(Node), block: T.nilable(BlockParameterNode), location: Location).void } + def initialize(requireds, optionals, posts, rest, keywords, keyword_rest, block, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ParametersNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a parenthesized expression + # + # (10 + 34) + # ^^^^^^^^^ + class ParenthesesNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :body + + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).void } + def initialize(body, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ParenthesesNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `^` operator for pinning an expression in a + # pattern matching expression. + # + # foo in ^(bar) + # ^^^^^^ + class PinnedExpressionNode < Node + sig { returns(Node) } + attr_reader :expression + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Location) } + attr_reader :lparen_loc + + sig { returns(Location) } + attr_reader :rparen_loc + + sig { params(expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location).void } + def initialize(expression, operator_loc, lparen_loc, rparen_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(PinnedExpressionNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { returns(String) } + def lparen; end + + sig { returns(String) } + def rparen; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `^` operator for pinning a variable in a pattern + # matching expression. + # + # foo in ^bar + # ^^^^ + class PinnedVariableNode < Node + sig { returns(Node) } + attr_reader :variable + + sig { returns(Location) } + attr_reader :operator_loc + + sig { params(variable: Node, operator_loc: Location, location: Location).void } + def initialize(variable, operator_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(PinnedVariableNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `END` keyword. + # + # END { foo } + # ^^^^^^^^^^^ + class PostExecutionNode < Node + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).void } + def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(PostExecutionNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `BEGIN` keyword. + # + # BEGIN { foo } + # ^^^^^^^^^^^^^ + class PreExecutionNode < Node + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).void } + def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(PreExecutionNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # The top level node of any parse tree. + class ProgramNode < Node + sig { returns(T::Array[Symbol]) } + attr_reader :locals + + sig { returns(StatementsNode) } + attr_reader :statements + + sig { params(locals: T::Array[Symbol], statements: StatementsNode, location: Location).void } + def initialize(locals, statements, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ProgramNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `..` or `...` operators. + # + # 1..2 + # ^^^^ + # + # c if a =~ /left/ ... b =~ /right/ + # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + class RangeNode < Node + sig { returns(T.nilable(Node)) } + attr_reader :left + + sig { returns(T.nilable(Node)) } + attr_reader :right + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Integer) } + attr_reader :flags + + sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).void } + def initialize(left, right, operator_loc, flags, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RangeNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { returns(T::Boolean) } + def exclude_end?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a rational number literal. + # + # 1.0r + # ^^^^ + class RationalNode < Node + sig { returns(Node) } + attr_reader :numeric + + sig { params(numeric: Node, location: Location).void } + def initialize(numeric, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RationalNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `redo` keyword. + # + # redo + # ^^^^ + class RedoNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RedoNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a regular expression literal with no interpolation. + # + # /foo/i + # ^^^^^^ + class RegularExpressionNode < Node + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :content_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { returns(String) } + attr_reader :unescaped + + sig { returns(Integer) } + attr_reader :flags + + sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location).void } + def initialize(opening_loc, content_loc, closing_loc, unescaped, flags, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RegularExpressionNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def content; end + + sig { returns(String) } + def closing; end + + sig { returns(T::Boolean) } + def ignore_case?; end + + sig { returns(T::Boolean) } + def multi_line?; end + + sig { returns(T::Boolean) } + def extended?; end + + sig { returns(T::Boolean) } + def euc_jp?; end + + sig { returns(T::Boolean) } + def ascii_8bit?; end + + sig { returns(T::Boolean) } + def windows_31j?; end + + sig { returns(T::Boolean) } + def utf_8?; end + + sig { returns(T::Boolean) } + def once?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a destructured required parameter node. + # + # def foo((bar, baz)) + # ^^^^^^^^^^ + # end + class RequiredDestructuredParameterNode < Node + sig { returns(T::Array[Node]) } + attr_reader :parameters + + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { params(parameters: T::Array[Node], opening_loc: Location, closing_loc: Location, location: Location).void } + def initialize(parameters, opening_loc, closing_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RequiredDestructuredParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a required parameter to a method, block, or lambda definition. + # + # def a(b) + # ^ + # end + class RequiredParameterNode < Node + sig { returns(Symbol) } + attr_reader :name + + sig { params(name: Symbol, location: Location).void } + def initialize(name, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RequiredParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an expression modified with a rescue. + # + # foo rescue nil + # ^^^^^^^^^^^^^^ + class RescueModifierNode < Node + sig { returns(Node) } + attr_reader :expression + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(Node) } + attr_reader :rescue_expression + + sig { params(expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location).void } + def initialize(expression, keyword_loc, rescue_expression, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RescueModifierNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a rescue statement. + # + # begin + # rescue Foo, *splat, Bar => ex + # ^^^^^^ + # foo + # end + # + # `Foo, *splat, Bar` are in the `exceptions` field. + # `ex` is in the `exception` field. + class RescueNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(T::Array[Node]) } + attr_reader :exceptions + + sig { returns(T.nilable(Location)) } + attr_reader :operator_loc + + sig { returns(T.nilable(Node)) } + attr_reader :reference + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(T.nilable(RescueNode)) } + attr_reader :consequent + + sig { params(keyword_loc: Location, exceptions: T::Array[Node], operator_loc: T.nilable(Location), reference: T.nilable(Node), statements: T.nilable(StatementsNode), consequent: T.nilable(RescueNode), location: Location).void } + def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RescueNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a rest parameter to a method, block, or lambda definition. + # + # def a(*b) + # ^^ + # end + class RestParameterNode < Node + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(T.nilable(Location)) } + attr_reader :name_loc + + sig { params(operator_loc: Location, name_loc: T.nilable(Location), location: Location).void } + def initialize(operator_loc, name_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RestParameterNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { returns(T.nilable(String)) } + def name; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `retry` keyword. + # + # retry + # ^^^^^ + class RetryNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(RetryNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `return` keyword. + # + # return 1 + # ^^^^^^^^ + class ReturnNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { params(keyword_loc: Location, arguments: T.nilable(ArgumentsNode), location: Location).void } + def initialize(keyword_loc, arguments, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(ReturnNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the `self` keyword. + # + # self + # ^^^^ + class SelfNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SelfNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a singleton class declaration involving the `class` keyword. + # + # class << self end + # ^^^^^^^^^^^^^^^^^ + class SingletonClassNode < Node + sig { returns(T::Array[Symbol]) } + attr_reader :locals + + sig { returns(Location) } + attr_reader :class_keyword_loc + + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(Node) } + attr_reader :expression + + sig { returns(T.nilable(Node)) } + attr_reader :body + + sig { returns(Location) } + attr_reader :end_keyword_loc + + sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: T.nilable(Node), end_keyword_loc: Location, location: Location).void } + def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SingletonClassNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def class_keyword; end + + sig { returns(String) } + def operator; end + + sig { returns(String) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `__ENCODING__` keyword. + # + # __ENCODING__ + # ^^^^^^^^^^^^ + class SourceEncodingNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SourceEncodingNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `__FILE__` keyword. + # + # __FILE__ + # ^^^^^^^^ + class SourceFileNode < Node + sig { returns(String) } + attr_reader :filepath + + sig { params(filepath: String, location: Location).void } + def initialize(filepath, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SourceFileNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `__LINE__` keyword. + # + # __LINE__ + # ^^^^^^^^ + class SourceLineNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SourceLineNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the splat operator. + # + # [*a] + # ^^ + class SplatNode < Node + sig { returns(Location) } + attr_reader :operator_loc + + sig { returns(T.nilable(Node)) } + attr_reader :expression + + sig { params(operator_loc: Location, expression: T.nilable(Node), location: Location).void } + def initialize(operator_loc, expression, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SplatNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def operator; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a set of statements contained within some scope. + # + # foo; bar; baz + # ^^^^^^^^^^^^^ + class StatementsNode < Node + sig { returns(T::Array[Node]) } + attr_reader :body + + sig { params(body: T::Array[Node], location: Location).void } + def initialize(body, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(StatementsNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of compile-time string concatenation. + # + # "foo" "bar" + # ^^^^^^^^^^^ + class StringConcatNode < Node + sig { returns(Node) } + attr_reader :left + + sig { returns(Node) } + attr_reader :right + + sig { params(left: Node, right: Node, location: Location).void } + def initialize(left, right, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(StringConcatNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a string literal, a string contained within a `%w` list, or + # plain string content within an interpolated string. + # + # "foo" + # ^^^^^ + # + # %w[foo] + # ^^^ + # + # "foo #{bar} baz" + # ^^^^ ^^^^ + class StringNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :content_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(String) } + attr_reader :unescaped + + sig { params(opening_loc: T.nilable(Location), content_loc: Location, closing_loc: T.nilable(Location), unescaped: String, location: Location).void } + def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(StringNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(String) } + def content; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `super` keyword with parentheses or arguments. + # + # super() + # ^^^^^^^ + # + # super foo, bar + # ^^^^^^^^^^^^^^ + class SuperNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(T.nilable(Location)) } + attr_reader :lparen_loc + + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(T.nilable(Location)) } + attr_reader :rparen_loc + + sig { returns(T.nilable(BlockNode)) } + attr_reader :block + + sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), block: T.nilable(BlockNode), location: Location).void } + def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SuperNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents a symbol literal or a symbol contained within a `%i` list. + # + # :foo + # ^^^^ + # + # %i[foo] + # ^^^ + class SymbolNode < Node + sig { returns(T.nilable(Location)) } + attr_reader :opening_loc + + sig { returns(T.nilable(Location)) } + attr_reader :value_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(String) } + attr_reader :unescaped + + sig { params(opening_loc: T.nilable(Location), value_loc: T.nilable(Location), closing_loc: T.nilable(Location), unescaped: String, location: Location).void } + def initialize(opening_loc, value_loc, closing_loc, unescaped, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(SymbolNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(String)) } + def value; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the literal `true` keyword. + # + # true + # ^^^^ + class TrueNode < Node + sig { params(location: Location).void } + def initialize(location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(TrueNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `undef` keyword. + # + # undef :foo, :bar, :baz + # ^^^^^^^^^^^^^^^^^^^^^^ + class UndefNode < Node + sig { returns(T::Array[Node]) } + attr_reader :names + + sig { returns(Location) } + attr_reader :keyword_loc + + sig { params(names: T::Array[Node], keyword_loc: Location, location: Location).void } + def initialize(names, keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(UndefNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `unless` keyword, either in the block form or the modifier form. + # + # bar unless foo + # ^^^^^^^^^^^^^^ + # + # unless foo then bar end + # ^^^^^^^^^^^^^^^^^^^^^^^ + class UnlessNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(Node) } + attr_reader :predicate + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(T.nilable(ElseNode)) } + attr_reader :consequent + + sig { returns(T.nilable(Location)) } + attr_reader :end_keyword_loc + + sig { params(keyword_loc: Location, predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(ElseNode), end_keyword_loc: T.nilable(Location), location: Location).void } + def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(UnlessNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `until` keyword, either in the block form or the modifier form. + # + # bar until foo + # ^^^^^^^^^^^^^ + # + # until foo do bar end + # ^^^^^^^^^^^^^^^^^^^^ + class UntilNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(Node) } + attr_reader :predicate + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Integer) } + attr_reader :flags + + sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).void } + def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(UntilNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T::Boolean) } + def begin_modifier?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `when` keyword within a case statement. + # + # case true + # when true + # ^^^^^^^^^ + # end + class WhenNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(T::Array[Node]) } + attr_reader :conditions + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { params(keyword_loc: Location, conditions: T::Array[Node], statements: T.nilable(StatementsNode), location: Location).void } + def initialize(keyword_loc, conditions, statements, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(WhenNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `while` keyword, either in the block form or the modifier form. + # + # bar while foo + # ^^^^^^^^^^^^^ + # + # while foo do bar end + # ^^^^^^^^^^^^^^^^^^^^ + class WhileNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(T.nilable(Location)) } + attr_reader :closing_loc + + sig { returns(Node) } + attr_reader :predicate + + sig { returns(T.nilable(StatementsNode)) } + attr_reader :statements + + sig { returns(Integer) } + attr_reader :flags + + sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).void } + def initialize(keyword_loc, closing_loc, predicate, statements, flags, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + def set_newline_flag(newline_marked); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(WhileNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T::Boolean) } + def begin_modifier?; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents an xstring literal with no interpolation. + # + # `foo` + # ^^^^^ + class XStringNode < Node + sig { returns(Location) } + attr_reader :opening_loc + + sig { returns(Location) } + attr_reader :content_loc + + sig { returns(Location) } + attr_reader :closing_loc + + sig { returns(String) } + attr_reader :unescaped + + sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location).void } + def initialize(opening_loc, content_loc, closing_loc, unescaped, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(XStringNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def opening; end + + sig { returns(String) } + def content; end + + sig { returns(String) } + def closing; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + # Represents the use of the `yield` keyword. + # + # yield 1 + # ^^^^^^^ + class YieldNode < Node + sig { returns(Location) } + attr_reader :keyword_loc + + sig { returns(T.nilable(Location)) } + attr_reader :lparen_loc + + sig { returns(T.nilable(ArgumentsNode)) } + attr_reader :arguments + + sig { returns(T.nilable(Location)) } + attr_reader :rparen_loc + + sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), location: Location).void } + def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location); end + + sig { params(visitor: Visitor).void } + def accept(visitor); end + + sig { returns(T::Array[T.nilable(Node)]) } + def child_nodes; end + + sig { returns(T::Array[T.nilable(Node)]) } + def deconstruct; end + + sig { params(params: T.untyped).returns(YieldNode) } + def copy(**params); end + + sig { params(keys: T::Array[Symbol]).returns(T::Hash[Symbol, T.nilable(T.any(Node, T::Array[Node], String, Token, T::Array[Token], Location))]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def keyword; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { params(inspector: NodeInspector).returns(String) } + def inspect(inspector); end + end + + module CallNodeFlags + # &. operator + SAFE_NAVIGATION = 1 << 0 + + # a call that could have been a local variable + VARIABLE_CALL = 1 << 1 + end + + module LoopFlags + # a loop after a begin statement, so the body is executed first before the condition + BEGIN_MODIFIER = 1 << 0 + end + + module RangeFlags + # ... operator + EXCLUDE_END = 1 << 0 + end + + module RegularExpressionFlags + # i - ignores the case of characters when matching + IGNORE_CASE = 1 << 0 + + # m - allows $ to match the end of lines within strings + MULTI_LINE = 1 << 1 + + # x - ignores whitespace and allows comments in regular expressions + EXTENDED = 1 << 2 + + # e - forces the EUC-JP encoding + EUC_JP = 1 << 3 + + # n - forces the ASCII-8BIT encoding + ASCII_8BIT = 1 << 4 + + # s - forces the Windows-31J encoding + WINDOWS_31J = 1 << 5 + + # u - forces the UTF-8 encoding + UTF_8 = 1 << 6 + + # o - only interpolates values into the regular expression once + ONCE = 1 << 7 + end + + class Visitor < BasicVisitor + # Visit a AliasNode node + sig { params(node: AliasNode).void } + def visit_alias_node(node); end + + # Visit a AlternationPatternNode node + sig { params(node: AlternationPatternNode).void } + def visit_alternation_pattern_node(node); end + + # Visit a AndNode node + sig { params(node: AndNode).void } + def visit_and_node(node); end + + # Visit a ArgumentsNode node + sig { params(node: ArgumentsNode).void } + def visit_arguments_node(node); end + + # Visit a ArrayNode node + sig { params(node: ArrayNode).void } + def visit_array_node(node); end + + # Visit a ArrayPatternNode node + sig { params(node: ArrayPatternNode).void } + def visit_array_pattern_node(node); end + + # Visit a AssocNode node + sig { params(node: AssocNode).void } + def visit_assoc_node(node); end + + # Visit a AssocSplatNode node + sig { params(node: AssocSplatNode).void } + def visit_assoc_splat_node(node); end + + # Visit a BackReferenceReadNode node + sig { params(node: BackReferenceReadNode).void } + def visit_back_reference_read_node(node); end + + # Visit a BeginNode node + sig { params(node: BeginNode).void } + def visit_begin_node(node); end + + # Visit a BlockArgumentNode node + sig { params(node: BlockArgumentNode).void } + def visit_block_argument_node(node); end + + # Visit a BlockLocalVariableNode node + sig { params(node: BlockLocalVariableNode).void } + def visit_block_local_variable_node(node); end + + # Visit a BlockNode node + sig { params(node: BlockNode).void } + def visit_block_node(node); end + + # Visit a BlockParameterNode node + sig { params(node: BlockParameterNode).void } + def visit_block_parameter_node(node); end + + # Visit a BlockParametersNode node + sig { params(node: BlockParametersNode).void } + def visit_block_parameters_node(node); end + + # Visit a BreakNode node + sig { params(node: BreakNode).void } + def visit_break_node(node); end + + # Visit a CallAndWriteNode node + sig { params(node: CallAndWriteNode).void } + def visit_call_and_write_node(node); end + + # Visit a CallNode node + sig { params(node: CallNode).void } + def visit_call_node(node); end + + # Visit a CallOperatorWriteNode node + sig { params(node: CallOperatorWriteNode).void } + def visit_call_operator_write_node(node); end + + # Visit a CallOrWriteNode node + sig { params(node: CallOrWriteNode).void } + def visit_call_or_write_node(node); end + + # Visit a CapturePatternNode node + sig { params(node: CapturePatternNode).void } + def visit_capture_pattern_node(node); end + + # Visit a CaseNode node + sig { params(node: CaseNode).void } + def visit_case_node(node); end + + # Visit a ClassNode node + sig { params(node: ClassNode).void } + def visit_class_node(node); end + + # Visit a ClassVariableAndWriteNode node + sig { params(node: ClassVariableAndWriteNode).void } + def visit_class_variable_and_write_node(node); end + + # Visit a ClassVariableOperatorWriteNode node + sig { params(node: ClassVariableOperatorWriteNode).void } + def visit_class_variable_operator_write_node(node); end + + # Visit a ClassVariableOrWriteNode node + sig { params(node: ClassVariableOrWriteNode).void } + def visit_class_variable_or_write_node(node); end + + # Visit a ClassVariableReadNode node + sig { params(node: ClassVariableReadNode).void } + def visit_class_variable_read_node(node); end + + # Visit a ClassVariableTargetNode node + sig { params(node: ClassVariableTargetNode).void } + def visit_class_variable_target_node(node); end + + # Visit a ClassVariableWriteNode node + sig { params(node: ClassVariableWriteNode).void } + def visit_class_variable_write_node(node); end + + # Visit a ConstantAndWriteNode node + sig { params(node: ConstantAndWriteNode).void } + def visit_constant_and_write_node(node); end + + # Visit a ConstantOperatorWriteNode node + sig { params(node: ConstantOperatorWriteNode).void } + def visit_constant_operator_write_node(node); end + + # Visit a ConstantOrWriteNode node + sig { params(node: ConstantOrWriteNode).void } + def visit_constant_or_write_node(node); end + + # Visit a ConstantPathAndWriteNode node + sig { params(node: ConstantPathAndWriteNode).void } + def visit_constant_path_and_write_node(node); end + + # Visit a ConstantPathNode node + sig { params(node: ConstantPathNode).void } + def visit_constant_path_node(node); end + + # Visit a ConstantPathOperatorWriteNode node + sig { params(node: ConstantPathOperatorWriteNode).void } + def visit_constant_path_operator_write_node(node); end + + # Visit a ConstantPathOrWriteNode node + sig { params(node: ConstantPathOrWriteNode).void } + def visit_constant_path_or_write_node(node); end + + # Visit a ConstantPathTargetNode node + sig { params(node: ConstantPathTargetNode).void } + def visit_constant_path_target_node(node); end + + # Visit a ConstantPathWriteNode node + sig { params(node: ConstantPathWriteNode).void } + def visit_constant_path_write_node(node); end + + # Visit a ConstantReadNode node + sig { params(node: ConstantReadNode).void } + def visit_constant_read_node(node); end + + # Visit a ConstantTargetNode node + sig { params(node: ConstantTargetNode).void } + def visit_constant_target_node(node); end + + # Visit a ConstantWriteNode node + sig { params(node: ConstantWriteNode).void } + def visit_constant_write_node(node); end + + # Visit a DefNode node + sig { params(node: DefNode).void } + def visit_def_node(node); end + + # Visit a DefinedNode node + sig { params(node: DefinedNode).void } + def visit_defined_node(node); end + + # Visit a ElseNode node + sig { params(node: ElseNode).void } + def visit_else_node(node); end + + # Visit a EmbeddedStatementsNode node + sig { params(node: EmbeddedStatementsNode).void } + def visit_embedded_statements_node(node); end + + # Visit a EmbeddedVariableNode node + sig { params(node: EmbeddedVariableNode).void } + def visit_embedded_variable_node(node); end + + # Visit a EnsureNode node + sig { params(node: EnsureNode).void } + def visit_ensure_node(node); end + + # Visit a FalseNode node + sig { params(node: FalseNode).void } + def visit_false_node(node); end + + # Visit a FindPatternNode node + sig { params(node: FindPatternNode).void } + def visit_find_pattern_node(node); end + + # Visit a FlipFlopNode node + sig { params(node: FlipFlopNode).void } + def visit_flip_flop_node(node); end + + # Visit a FloatNode node + sig { params(node: FloatNode).void } + def visit_float_node(node); end + + # Visit a ForNode node + sig { params(node: ForNode).void } + def visit_for_node(node); end + + # Visit a ForwardingArgumentsNode node + sig { params(node: ForwardingArgumentsNode).void } + def visit_forwarding_arguments_node(node); end + + # Visit a ForwardingParameterNode node + sig { params(node: ForwardingParameterNode).void } + def visit_forwarding_parameter_node(node); end + + # Visit a ForwardingSuperNode node + sig { params(node: ForwardingSuperNode).void } + def visit_forwarding_super_node(node); end + + # Visit a GlobalVariableAndWriteNode node + sig { params(node: GlobalVariableAndWriteNode).void } + def visit_global_variable_and_write_node(node); end + + # Visit a GlobalVariableOperatorWriteNode node + sig { params(node: GlobalVariableOperatorWriteNode).void } + def visit_global_variable_operator_write_node(node); end + + # Visit a GlobalVariableOrWriteNode node + sig { params(node: GlobalVariableOrWriteNode).void } + def visit_global_variable_or_write_node(node); end + + # Visit a GlobalVariableReadNode node + sig { params(node: GlobalVariableReadNode).void } + def visit_global_variable_read_node(node); end + + # Visit a GlobalVariableTargetNode node + sig { params(node: GlobalVariableTargetNode).void } + def visit_global_variable_target_node(node); end + + # Visit a GlobalVariableWriteNode node + sig { params(node: GlobalVariableWriteNode).void } + def visit_global_variable_write_node(node); end + + # Visit a HashNode node + sig { params(node: HashNode).void } + def visit_hash_node(node); end + + # Visit a HashPatternNode node + sig { params(node: HashPatternNode).void } + def visit_hash_pattern_node(node); end + + # Visit a IfNode node + sig { params(node: IfNode).void } + def visit_if_node(node); end + + # Visit a ImaginaryNode node + sig { params(node: ImaginaryNode).void } + def visit_imaginary_node(node); end + + # Visit a InNode node + sig { params(node: InNode).void } + def visit_in_node(node); end + + # Visit a InstanceVariableAndWriteNode node + sig { params(node: InstanceVariableAndWriteNode).void } + def visit_instance_variable_and_write_node(node); end + + # Visit a InstanceVariableOperatorWriteNode node + sig { params(node: InstanceVariableOperatorWriteNode).void } + def visit_instance_variable_operator_write_node(node); end + + # Visit a InstanceVariableOrWriteNode node + sig { params(node: InstanceVariableOrWriteNode).void } + def visit_instance_variable_or_write_node(node); end + + # Visit a InstanceVariableReadNode node + sig { params(node: InstanceVariableReadNode).void } + def visit_instance_variable_read_node(node); end + + # Visit a InstanceVariableTargetNode node + sig { params(node: InstanceVariableTargetNode).void } + def visit_instance_variable_target_node(node); end + + # Visit a InstanceVariableWriteNode node + sig { params(node: InstanceVariableWriteNode).void } + def visit_instance_variable_write_node(node); end + + # Visit a IntegerNode node + sig { params(node: IntegerNode).void } + def visit_integer_node(node); end + + # Visit a InterpolatedRegularExpressionNode node + sig { params(node: InterpolatedRegularExpressionNode).void } + def visit_interpolated_regular_expression_node(node); end + + # Visit a InterpolatedStringNode node + sig { params(node: InterpolatedStringNode).void } + def visit_interpolated_string_node(node); end + + # Visit a InterpolatedSymbolNode node + sig { params(node: InterpolatedSymbolNode).void } + def visit_interpolated_symbol_node(node); end + + # Visit a InterpolatedXStringNode node + sig { params(node: InterpolatedXStringNode).void } + def visit_interpolated_x_string_node(node); end + + # Visit a KeywordHashNode node + sig { params(node: KeywordHashNode).void } + def visit_keyword_hash_node(node); end + + # Visit a KeywordParameterNode node + sig { params(node: KeywordParameterNode).void } + def visit_keyword_parameter_node(node); end + + # Visit a KeywordRestParameterNode node + sig { params(node: KeywordRestParameterNode).void } + def visit_keyword_rest_parameter_node(node); end + + # Visit a LambdaNode node + sig { params(node: LambdaNode).void } + def visit_lambda_node(node); end + + # Visit a LocalVariableAndWriteNode node + sig { params(node: LocalVariableAndWriteNode).void } + def visit_local_variable_and_write_node(node); end + + # Visit a LocalVariableOperatorWriteNode node + sig { params(node: LocalVariableOperatorWriteNode).void } + def visit_local_variable_operator_write_node(node); end + + # Visit a LocalVariableOrWriteNode node + sig { params(node: LocalVariableOrWriteNode).void } + def visit_local_variable_or_write_node(node); end + + # Visit a LocalVariableReadNode node + sig { params(node: LocalVariableReadNode).void } + def visit_local_variable_read_node(node); end + + # Visit a LocalVariableTargetNode node + sig { params(node: LocalVariableTargetNode).void } + def visit_local_variable_target_node(node); end + + # Visit a LocalVariableWriteNode node + sig { params(node: LocalVariableWriteNode).void } + def visit_local_variable_write_node(node); end + + # Visit a MatchPredicateNode node + sig { params(node: MatchPredicateNode).void } + def visit_match_predicate_node(node); end + + # Visit a MatchRequiredNode node + sig { params(node: MatchRequiredNode).void } + def visit_match_required_node(node); end + + # Visit a MissingNode node + sig { params(node: MissingNode).void } + def visit_missing_node(node); end + + # Visit a ModuleNode node + sig { params(node: ModuleNode).void } + def visit_module_node(node); end + + # Visit a MultiWriteNode node + sig { params(node: MultiWriteNode).void } + def visit_multi_write_node(node); end + + # Visit a NextNode node + sig { params(node: NextNode).void } + def visit_next_node(node); end + + # Visit a NilNode node + sig { params(node: NilNode).void } + def visit_nil_node(node); end + + # Visit a NoKeywordsParameterNode node + sig { params(node: NoKeywordsParameterNode).void } + def visit_no_keywords_parameter_node(node); end + + # Visit a NumberedReferenceReadNode node + sig { params(node: NumberedReferenceReadNode).void } + def visit_numbered_reference_read_node(node); end + + # Visit a OptionalParameterNode node + sig { params(node: OptionalParameterNode).void } + def visit_optional_parameter_node(node); end + + # Visit a OrNode node + sig { params(node: OrNode).void } + def visit_or_node(node); end + + # Visit a ParametersNode node + sig { params(node: ParametersNode).void } + def visit_parameters_node(node); end + + # Visit a ParenthesesNode node + sig { params(node: ParenthesesNode).void } + def visit_parentheses_node(node); end + + # Visit a PinnedExpressionNode node + sig { params(node: PinnedExpressionNode).void } + def visit_pinned_expression_node(node); end + + # Visit a PinnedVariableNode node + sig { params(node: PinnedVariableNode).void } + def visit_pinned_variable_node(node); end + + # Visit a PostExecutionNode node + sig { params(node: PostExecutionNode).void } + def visit_post_execution_node(node); end + + # Visit a PreExecutionNode node + sig { params(node: PreExecutionNode).void } + def visit_pre_execution_node(node); end + + # Visit a ProgramNode node + sig { params(node: ProgramNode).void } + def visit_program_node(node); end + + # Visit a RangeNode node + sig { params(node: RangeNode).void } + def visit_range_node(node); end + + # Visit a RationalNode node + sig { params(node: RationalNode).void } + def visit_rational_node(node); end + + # Visit a RedoNode node + sig { params(node: RedoNode).void } + def visit_redo_node(node); end + + # Visit a RegularExpressionNode node + sig { params(node: RegularExpressionNode).void } + def visit_regular_expression_node(node); end + + # Visit a RequiredDestructuredParameterNode node + sig { params(node: RequiredDestructuredParameterNode).void } + def visit_required_destructured_parameter_node(node); end + + # Visit a RequiredParameterNode node + sig { params(node: RequiredParameterNode).void } + def visit_required_parameter_node(node); end + + # Visit a RescueModifierNode node + sig { params(node: RescueModifierNode).void } + def visit_rescue_modifier_node(node); end + + # Visit a RescueNode node + sig { params(node: RescueNode).void } + def visit_rescue_node(node); end + + # Visit a RestParameterNode node + sig { params(node: RestParameterNode).void } + def visit_rest_parameter_node(node); end + + # Visit a RetryNode node + sig { params(node: RetryNode).void } + def visit_retry_node(node); end + + # Visit a ReturnNode node + sig { params(node: ReturnNode).void } + def visit_return_node(node); end + + # Visit a SelfNode node + sig { params(node: SelfNode).void } + def visit_self_node(node); end + + # Visit a SingletonClassNode node + sig { params(node: SingletonClassNode).void } + def visit_singleton_class_node(node); end + + # Visit a SourceEncodingNode node + sig { params(node: SourceEncodingNode).void } + def visit_source_encoding_node(node); end + + # Visit a SourceFileNode node + sig { params(node: SourceFileNode).void } + def visit_source_file_node(node); end + + # Visit a SourceLineNode node + sig { params(node: SourceLineNode).void } + def visit_source_line_node(node); end + + # Visit a SplatNode node + sig { params(node: SplatNode).void } + def visit_splat_node(node); end + + # Visit a StatementsNode node + sig { params(node: StatementsNode).void } + def visit_statements_node(node); end + + # Visit a StringConcatNode node + sig { params(node: StringConcatNode).void } + def visit_string_concat_node(node); end + + # Visit a StringNode node + sig { params(node: StringNode).void } + def visit_string_node(node); end + + # Visit a SuperNode node + sig { params(node: SuperNode).void } + def visit_super_node(node); end + + # Visit a SymbolNode node + sig { params(node: SymbolNode).void } + def visit_symbol_node(node); end + + # Visit a TrueNode node + sig { params(node: TrueNode).void } + def visit_true_node(node); end + + # Visit a UndefNode node + sig { params(node: UndefNode).void } + def visit_undef_node(node); end + + # Visit a UnlessNode node + sig { params(node: UnlessNode).void } + def visit_unless_node(node); end + + # Visit a UntilNode node + sig { params(node: UntilNode).void } + def visit_until_node(node); end + + # Visit a WhenNode node + sig { params(node: WhenNode).void } + def visit_when_node(node); end + + # Visit a WhileNode node + sig { params(node: WhileNode).void } + def visit_while_node(node); end + + # Visit a XStringNode node + sig { params(node: XStringNode).void } + def visit_x_string_node(node); end + + # Visit a YieldNode node + sig { params(node: YieldNode).void } + def visit_yield_node(node); end + end + + module DSL + private + + # Create a new Location object + sig { params(source: T.nilable(Source), start_offset: Integer, length: Integer).returns(Location) } + def Location(source, start_offset, length); end + + # Create a new AliasNode node + sig { params(new_name: Node, old_name: Node, keyword_loc: Location, location: Location).returns(AliasNode) } + def AliasNode(new_name, old_name, keyword_loc, location); end + + # Create a new AlternationPatternNode node + sig { params(left: Node, right: Node, operator_loc: Location, location: Location).returns(AlternationPatternNode) } + def AlternationPatternNode(left, right, operator_loc, location); end + + # Create a new AndNode node + sig { params(left: Node, right: Node, operator_loc: Location, location: Location).returns(AndNode) } + def AndNode(left, right, operator_loc, location); end + + # Create a new ArgumentsNode node + sig { params(arguments: T::Array[Node], location: Location).returns(ArgumentsNode) } + def ArgumentsNode(arguments, location); end + + # Create a new ArrayNode node + sig { params(elements: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(ArrayNode) } + def ArrayNode(elements, opening_loc, closing_loc, location); end + + # Create a new ArrayPatternNode node + sig { params(constant: T.nilable(Node), requireds: T::Array[Node], rest: T.nilable(Node), posts: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(ArrayPatternNode) } + def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location); end + + # Create a new AssocNode node + sig { params(key: Node, value: T.nilable(Node), operator_loc: T.nilable(Location), location: Location).returns(AssocNode) } + def AssocNode(key, value, operator_loc, location); end + + # Create a new AssocSplatNode node + sig { params(value: T.nilable(Node), operator_loc: Location, location: Location).returns(AssocSplatNode) } + def AssocSplatNode(value, operator_loc, location); end + + # Create a new BackReferenceReadNode node + sig { params(location: Location).returns(BackReferenceReadNode) } + def BackReferenceReadNode(location); end + + # Create a new BeginNode node + sig { params(begin_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), rescue_clause: T.nilable(RescueNode), else_clause: T.nilable(ElseNode), ensure_clause: T.nilable(EnsureNode), end_keyword_loc: T.nilable(Location), location: Location).returns(BeginNode) } + def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end + + # Create a new BlockArgumentNode node + sig { params(expression: T.nilable(Node), operator_loc: Location, location: Location).returns(BlockArgumentNode) } + def BlockArgumentNode(expression, operator_loc, location); end + + # Create a new BlockLocalVariableNode node + sig { params(name: Symbol, location: Location).returns(BlockLocalVariableNode) } + def BlockLocalVariableNode(name, location); end + + # Create a new BlockNode node + sig { params(locals: T::Array[Symbol], parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).returns(BlockNode) } + def BlockNode(locals, parameters, body, opening_loc, closing_loc, location); end + + # Create a new BlockParameterNode node + sig { params(name_loc: T.nilable(Location), operator_loc: Location, location: Location).returns(BlockParameterNode) } + def BlockParameterNode(name_loc, operator_loc, location); end + + # Create a new BlockParametersNode node + sig { params(parameters: T.nilable(ParametersNode), locals: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(BlockParametersNode) } + def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location); end + + # Create a new BreakNode node + sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).returns(BreakNode) } + def BreakNode(arguments, keyword_loc, location); end + + # Create a new CallAndWriteNode node + sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location).returns(CallAndWriteNode) } + def CallAndWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location); end + + # Create a new CallNode node + sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), block: T.nilable(BlockNode), flags: Integer, name: String, location: Location).returns(CallNode) } + def CallNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location); end + + # Create a new CallOperatorWriteNode node + sig { params(target: T.nilable(Node), operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(CallOperatorWriteNode) } + def CallOperatorWriteNode(target, operator_loc, value, operator, location); end + + # Create a new CallOrWriteNode node + sig { params(receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location).returns(CallOrWriteNode) } + def CallOrWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location); end + + # Create a new CapturePatternNode node + sig { params(value: Node, target: Node, operator_loc: Location, location: Location).returns(CapturePatternNode) } + def CapturePatternNode(value, target, operator_loc, location); end + + # Create a new CaseNode node + sig { params(predicate: T.nilable(Node), conditions: T::Array[Node], consequent: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location, location: Location).returns(CaseNode) } + def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end + + # Create a new ClassNode node + sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: T.nilable(Location), superclass: T.nilable(Node), body: T.nilable(Node), end_keyword_loc: Location, name: String, location: Location).returns(ClassNode) } + def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end + + # Create a new ClassVariableAndWriteNode node + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ClassVariableAndWriteNode) } + def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location); end + + # Create a new ClassVariableOperatorWriteNode node + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(ClassVariableOperatorWriteNode) } + def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end + + # Create a new ClassVariableOrWriteNode node + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ClassVariableOrWriteNode) } + def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location); end + + # Create a new ClassVariableReadNode node + sig { params(name: Symbol, location: Location).returns(ClassVariableReadNode) } + def ClassVariableReadNode(name, location); end + + # Create a new ClassVariableTargetNode node + sig { params(name: Symbol, location: Location).returns(ClassVariableTargetNode) } + def ClassVariableTargetNode(name, location); end + + # Create a new ClassVariableWriteNode node + sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: T.nilable(Location), location: Location).returns(ClassVariableWriteNode) } + def ClassVariableWriteNode(name, name_loc, value, operator_loc, location); end + + # Create a new ConstantAndWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ConstantAndWriteNode) } + def ConstantAndWriteNode(name_loc, operator_loc, value, location); end + + # Create a new ConstantOperatorWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(ConstantOperatorWriteNode) } + def ConstantOperatorWriteNode(name_loc, operator_loc, value, operator, location); end + + # Create a new ConstantOrWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(ConstantOrWriteNode) } + def ConstantOrWriteNode(name_loc, operator_loc, value, location); end + + # Create a new ConstantPathAndWriteNode node + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).returns(ConstantPathAndWriteNode) } + def ConstantPathAndWriteNode(target, operator_loc, value, location); end + + # Create a new ConstantPathNode node + sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).returns(ConstantPathNode) } + def ConstantPathNode(parent, child, delimiter_loc, location); end + + # Create a new ConstantPathOperatorWriteNode node + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(ConstantPathOperatorWriteNode) } + def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location); end + + # Create a new ConstantPathOrWriteNode node + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).returns(ConstantPathOrWriteNode) } + def ConstantPathOrWriteNode(target, operator_loc, value, location); end + + # Create a new ConstantPathTargetNode node + sig { params(parent: T.nilable(Node), child: Node, delimiter_loc: Location, location: Location).returns(ConstantPathTargetNode) } + def ConstantPathTargetNode(parent, child, delimiter_loc, location); end + + # Create a new ConstantPathWriteNode node + sig { params(target: ConstantPathNode, operator_loc: Location, value: Node, location: Location).returns(ConstantPathWriteNode) } + def ConstantPathWriteNode(target, operator_loc, value, location); end + + # Create a new ConstantReadNode node + sig { params(location: Location).returns(ConstantReadNode) } + def ConstantReadNode(location); end + + # Create a new ConstantTargetNode node + sig { params(location: Location).returns(ConstantTargetNode) } + def ConstantTargetNode(location); end + + # Create a new ConstantWriteNode node + sig { params(name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(ConstantWriteNode) } + def ConstantWriteNode(name_loc, value, operator_loc, location); end + + # Create a new DefNode node + sig { params(name_loc: Location, receiver: T.nilable(Node), parameters: T.nilable(ParametersNode), body: T.nilable(Node), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: T.nilable(Location), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), equal_loc: T.nilable(Location), end_keyword_loc: T.nilable(Location), location: Location).returns(DefNode) } + def DefNode(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end + + # Create a new DefinedNode node + sig { params(lparen_loc: T.nilable(Location), value: Node, rparen_loc: T.nilable(Location), keyword_loc: Location, location: Location).returns(DefinedNode) } + def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location); end + + # Create a new ElseNode node + sig { params(else_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: T.nilable(Location), location: Location).returns(ElseNode) } + def ElseNode(else_keyword_loc, statements, end_keyword_loc, location); end + + # Create a new EmbeddedStatementsNode node + sig { params(opening_loc: Location, statements: T.nilable(StatementsNode), closing_loc: Location, location: Location).returns(EmbeddedStatementsNode) } + def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location); end + + # Create a new EmbeddedVariableNode node + sig { params(operator_loc: Location, variable: Node, location: Location).returns(EmbeddedVariableNode) } + def EmbeddedVariableNode(operator_loc, variable, location); end + + # Create a new EnsureNode node + sig { params(ensure_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: Location, location: Location).returns(EnsureNode) } + def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location); end + + # Create a new FalseNode node + sig { params(location: Location).returns(FalseNode) } + def FalseNode(location); end + + # Create a new FindPatternNode node + sig { params(constant: T.nilable(Node), left: Node, requireds: T::Array[Node], right: Node, opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(FindPatternNode) } + def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location); end + + # Create a new FlipFlopNode node + sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).returns(FlipFlopNode) } + def FlipFlopNode(left, right, operator_loc, flags, location); end + + # Create a new FloatNode node + sig { params(location: Location).returns(FloatNode) } + def FloatNode(location); end + + # Create a new ForNode node + sig { params(index: Node, collection: Node, statements: T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: T.nilable(Location), end_keyword_loc: Location, location: Location).returns(ForNode) } + def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end + + # Create a new ForwardingArgumentsNode node + sig { params(location: Location).returns(ForwardingArgumentsNode) } + def ForwardingArgumentsNode(location); end + + # Create a new ForwardingParameterNode node + sig { params(location: Location).returns(ForwardingParameterNode) } + def ForwardingParameterNode(location); end + + # Create a new ForwardingSuperNode node + sig { params(block: T.nilable(BlockNode), location: Location).returns(ForwardingSuperNode) } + def ForwardingSuperNode(block, location); end + + # Create a new GlobalVariableAndWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(GlobalVariableAndWriteNode) } + def GlobalVariableAndWriteNode(name_loc, operator_loc, value, location); end + + # Create a new GlobalVariableOperatorWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(GlobalVariableOperatorWriteNode) } + def GlobalVariableOperatorWriteNode(name_loc, operator_loc, value, operator, location); end + + # Create a new GlobalVariableOrWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(GlobalVariableOrWriteNode) } + def GlobalVariableOrWriteNode(name_loc, operator_loc, value, location); end + + # Create a new GlobalVariableReadNode node + sig { params(location: Location).returns(GlobalVariableReadNode) } + def GlobalVariableReadNode(location); end + + # Create a new GlobalVariableTargetNode node + sig { params(location: Location).returns(GlobalVariableTargetNode) } + def GlobalVariableTargetNode(location); end + + # Create a new GlobalVariableWriteNode node + sig { params(name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(GlobalVariableWriteNode) } + def GlobalVariableWriteNode(name_loc, value, operator_loc, location); end + + # Create a new HashNode node + sig { params(opening_loc: Location, elements: T::Array[Node], closing_loc: Location, location: Location).returns(HashNode) } + def HashNode(opening_loc, elements, closing_loc, location); end + + # Create a new HashPatternNode node + sig { params(constant: T.nilable(Node), assocs: T::Array[Node], kwrest: T.nilable(Node), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location), location: Location).returns(HashPatternNode) } + def HashPatternNode(constant, assocs, kwrest, opening_loc, closing_loc, location); end + + # Create a new IfNode node + sig { params(if_keyword_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(Node), end_keyword_loc: T.nilable(Location), location: Location).returns(IfNode) } + def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + + # Create a new ImaginaryNode node + sig { params(numeric: Node, location: Location).returns(ImaginaryNode) } + def ImaginaryNode(numeric, location); end + + # Create a new InNode node + sig { params(pattern: Node, statements: T.nilable(StatementsNode), in_loc: Location, then_loc: T.nilable(Location), location: Location).returns(InNode) } + def InNode(pattern, statements, in_loc, then_loc, location); end + + # Create a new InstanceVariableAndWriteNode node + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(InstanceVariableAndWriteNode) } + def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location); end + + # Create a new InstanceVariableOperatorWriteNode node + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location).returns(InstanceVariableOperatorWriteNode) } + def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location); end + + # Create a new InstanceVariableOrWriteNode node + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(InstanceVariableOrWriteNode) } + def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location); end + + # Create a new InstanceVariableReadNode node + sig { params(name: Symbol, location: Location).returns(InstanceVariableReadNode) } + def InstanceVariableReadNode(name, location); end + + # Create a new InstanceVariableTargetNode node + sig { params(name: Symbol, location: Location).returns(InstanceVariableTargetNode) } + def InstanceVariableTargetNode(name, location); end + + # Create a new InstanceVariableWriteNode node + sig { params(name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(InstanceVariableWriteNode) } + def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location); end + + # Create a new IntegerNode node + sig { params(location: Location).returns(IntegerNode) } + def IntegerNode(location); end + + # Create a new InterpolatedRegularExpressionNode node + sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, flags: Integer, location: Location).returns(InterpolatedRegularExpressionNode) } + def InterpolatedRegularExpressionNode(opening_loc, parts, closing_loc, flags, location); end + + # Create a new InterpolatedStringNode node + sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).returns(InterpolatedStringNode) } + def InterpolatedStringNode(opening_loc, parts, closing_loc, location); end + + # Create a new InterpolatedSymbolNode node + sig { params(opening_loc: T.nilable(Location), parts: T::Array[Node], closing_loc: T.nilable(Location), location: Location).returns(InterpolatedSymbolNode) } + def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location); end + + # Create a new InterpolatedXStringNode node + sig { params(opening_loc: Location, parts: T::Array[Node], closing_loc: Location, location: Location).returns(InterpolatedXStringNode) } + def InterpolatedXStringNode(opening_loc, parts, closing_loc, location); end + + # Create a new KeywordHashNode node + sig { params(elements: T::Array[Node], location: Location).returns(KeywordHashNode) } + def KeywordHashNode(elements, location); end + + # Create a new KeywordParameterNode node + sig { params(name_loc: Location, value: T.nilable(Node), location: Location).returns(KeywordParameterNode) } + def KeywordParameterNode(name_loc, value, location); end + + # Create a new KeywordRestParameterNode node + sig { params(operator_loc: Location, name_loc: T.nilable(Location), location: Location).returns(KeywordRestParameterNode) } + def KeywordRestParameterNode(operator_loc, name_loc, location); end + + # Create a new LambdaNode node + sig { params(locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: T.nilable(BlockParametersNode), body: T.nilable(Node), location: Location).returns(LambdaNode) } + def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end + + # Create a new LocalVariableAndWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).returns(LocalVariableAndWriteNode) } + def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location); end + + # Create a new LocalVariableOperatorWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location).returns(LocalVariableOperatorWriteNode) } + def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location); end + + # Create a new LocalVariableOrWriteNode node + sig { params(name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location).returns(LocalVariableOrWriteNode) } + def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location); end + + # Create a new LocalVariableReadNode node + sig { params(name: Symbol, depth: Integer, location: Location).returns(LocalVariableReadNode) } + def LocalVariableReadNode(name, depth, location); end + + # Create a new LocalVariableTargetNode node + sig { params(name: Symbol, depth: Integer, location: Location).returns(LocalVariableTargetNode) } + def LocalVariableTargetNode(name, depth, location); end + + # Create a new LocalVariableWriteNode node + sig { params(name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location).returns(LocalVariableWriteNode) } + def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location); end + + # Create a new MatchPredicateNode node + sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).returns(MatchPredicateNode) } + def MatchPredicateNode(value, pattern, operator_loc, location); end + + # Create a new MatchRequiredNode node + sig { params(value: Node, pattern: Node, operator_loc: Location, location: Location).returns(MatchRequiredNode) } + def MatchRequiredNode(value, pattern, operator_loc, location); end + + # Create a new MissingNode node + sig { params(location: Location).returns(MissingNode) } + def MissingNode(location); end + + # Create a new ModuleNode node + sig { params(locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: T.nilable(Node), end_keyword_loc: Location, name: String, location: Location).returns(ModuleNode) } + def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end + + # Create a new MultiWriteNode node + sig { params(targets: T::Array[Node], operator_loc: T.nilable(Location), value: T.nilable(Node), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), location: Location).returns(MultiWriteNode) } + def MultiWriteNode(targets, operator_loc, value, lparen_loc, rparen_loc, location); end + + # Create a new NextNode node + sig { params(arguments: T.nilable(ArgumentsNode), keyword_loc: Location, location: Location).returns(NextNode) } + def NextNode(arguments, keyword_loc, location); end + + # Create a new NilNode node + sig { params(location: Location).returns(NilNode) } + def NilNode(location); end + + # Create a new NoKeywordsParameterNode node + sig { params(operator_loc: Location, keyword_loc: Location, location: Location).returns(NoKeywordsParameterNode) } + def NoKeywordsParameterNode(operator_loc, keyword_loc, location); end + + # Create a new NumberedReferenceReadNode node + sig { params(number: Integer, location: Location).returns(NumberedReferenceReadNode) } + def NumberedReferenceReadNode(number, location); end + + # Create a new OptionalParameterNode node + sig { params(name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location).returns(OptionalParameterNode) } + def OptionalParameterNode(name, name_loc, operator_loc, value, location); end + + # Create a new OrNode node + sig { params(left: Node, right: Node, operator_loc: Location, location: Location).returns(OrNode) } + def OrNode(left, right, operator_loc, location); end + + # Create a new ParametersNode node + sig { params(requireds: T::Array[Node], optionals: T::Array[Node], posts: T::Array[Node], rest: T.nilable(RestParameterNode), keywords: T::Array[Node], keyword_rest: T.nilable(Node), block: T.nilable(BlockParameterNode), location: Location).returns(ParametersNode) } + def ParametersNode(requireds, optionals, posts, rest, keywords, keyword_rest, block, location); end + + # Create a new ParenthesesNode node + sig { params(body: T.nilable(Node), opening_loc: Location, closing_loc: Location, location: Location).returns(ParenthesesNode) } + def ParenthesesNode(body, opening_loc, closing_loc, location); end + + # Create a new PinnedExpressionNode node + sig { params(expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location).returns(PinnedExpressionNode) } + def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location); end + + # Create a new PinnedVariableNode node + sig { params(variable: Node, operator_loc: Location, location: Location).returns(PinnedVariableNode) } + def PinnedVariableNode(variable, operator_loc, location); end + + # Create a new PostExecutionNode node + sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).returns(PostExecutionNode) } + def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location); end + + # Create a new PreExecutionNode node + sig { params(statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location).returns(PreExecutionNode) } + def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location); end + + # Create a new ProgramNode node + sig { params(locals: T::Array[Symbol], statements: StatementsNode, location: Location).returns(ProgramNode) } + def ProgramNode(locals, statements, location); end + + # Create a new RangeNode node + sig { params(left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location, flags: Integer, location: Location).returns(RangeNode) } + def RangeNode(left, right, operator_loc, flags, location); end + + # Create a new RationalNode node + sig { params(numeric: Node, location: Location).returns(RationalNode) } + def RationalNode(numeric, location); end + + # Create a new RedoNode node + sig { params(location: Location).returns(RedoNode) } + def RedoNode(location); end + + # Create a new RegularExpressionNode node + sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location).returns(RegularExpressionNode) } + def RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location); end + + # Create a new RequiredDestructuredParameterNode node + sig { params(parameters: T::Array[Node], opening_loc: Location, closing_loc: Location, location: Location).returns(RequiredDestructuredParameterNode) } + def RequiredDestructuredParameterNode(parameters, opening_loc, closing_loc, location); end + + # Create a new RequiredParameterNode node + sig { params(name: Symbol, location: Location).returns(RequiredParameterNode) } + def RequiredParameterNode(name, location); end + + # Create a new RescueModifierNode node + sig { params(expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location).returns(RescueModifierNode) } + def RescueModifierNode(expression, keyword_loc, rescue_expression, location); end + + # Create a new RescueNode node + sig { params(keyword_loc: Location, exceptions: T::Array[Node], operator_loc: T.nilable(Location), reference: T.nilable(Node), statements: T.nilable(StatementsNode), consequent: T.nilable(RescueNode), location: Location).returns(RescueNode) } + def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end + + # Create a new RestParameterNode node + sig { params(operator_loc: Location, name_loc: T.nilable(Location), location: Location).returns(RestParameterNode) } + def RestParameterNode(operator_loc, name_loc, location); end + + # Create a new RetryNode node + sig { params(location: Location).returns(RetryNode) } + def RetryNode(location); end + + # Create a new ReturnNode node + sig { params(keyword_loc: Location, arguments: T.nilable(ArgumentsNode), location: Location).returns(ReturnNode) } + def ReturnNode(keyword_loc, arguments, location); end + + # Create a new SelfNode node + sig { params(location: Location).returns(SelfNode) } + def SelfNode(location); end + + # Create a new SingletonClassNode node + sig { params(locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: T.nilable(Node), end_keyword_loc: Location, location: Location).returns(SingletonClassNode) } + def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end + + # Create a new SourceEncodingNode node + sig { params(location: Location).returns(SourceEncodingNode) } + def SourceEncodingNode(location); end + + # Create a new SourceFileNode node + sig { params(filepath: String, location: Location).returns(SourceFileNode) } + def SourceFileNode(filepath, location); end + + # Create a new SourceLineNode node + sig { params(location: Location).returns(SourceLineNode) } + def SourceLineNode(location); end + + # Create a new SplatNode node + sig { params(operator_loc: Location, expression: T.nilable(Node), location: Location).returns(SplatNode) } + def SplatNode(operator_loc, expression, location); end + + # Create a new StatementsNode node + sig { params(body: T::Array[Node], location: Location).returns(StatementsNode) } + def StatementsNode(body, location); end + + # Create a new StringConcatNode node + sig { params(left: Node, right: Node, location: Location).returns(StringConcatNode) } + def StringConcatNode(left, right, location); end + + # Create a new StringNode node + sig { params(opening_loc: T.nilable(Location), content_loc: Location, closing_loc: T.nilable(Location), unescaped: String, location: Location).returns(StringNode) } + def StringNode(opening_loc, content_loc, closing_loc, unescaped, location); end + + # Create a new SuperNode node + sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), block: T.nilable(BlockNode), location: Location).returns(SuperNode) } + def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end + + # Create a new SymbolNode node + sig { params(opening_loc: T.nilable(Location), value_loc: T.nilable(Location), closing_loc: T.nilable(Location), unescaped: String, location: Location).returns(SymbolNode) } + def SymbolNode(opening_loc, value_loc, closing_loc, unescaped, location); end + + # Create a new TrueNode node + sig { params(location: Location).returns(TrueNode) } + def TrueNode(location); end + + # Create a new UndefNode node + sig { params(names: T::Array[Node], keyword_loc: Location, location: Location).returns(UndefNode) } + def UndefNode(names, keyword_loc, location); end + + # Create a new UnlessNode node + sig { params(keyword_loc: Location, predicate: Node, statements: T.nilable(StatementsNode), consequent: T.nilable(ElseNode), end_keyword_loc: T.nilable(Location), location: Location).returns(UnlessNode) } + def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location); end + + # Create a new UntilNode node + sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).returns(UntilNode) } + def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location); end + + # Create a new WhenNode node + sig { params(keyword_loc: Location, conditions: T::Array[Node], statements: T.nilable(StatementsNode), location: Location).returns(WhenNode) } + def WhenNode(keyword_loc, conditions, statements, location); end + + # Create a new WhileNode node + sig { params(keyword_loc: Location, closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode), flags: Integer, location: Location).returns(WhileNode) } + def WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location); end + + # Create a new XStringNode node + sig { params(opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location).returns(XStringNode) } + def XStringNode(opening_loc, content_loc, closing_loc, unescaped, location); end + + # Create a new YieldNode node + sig { params(keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), location: Location).returns(YieldNode) } + def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location); end + end +end diff --git a/sorbet/tapioca/require.rb b/sorbet/tapioca/require.rb index 6eeced2a..0e93c7b3 100644 --- a/sorbet/tapioca/require.rb +++ b/sorbet/tapioca/require.rb @@ -2,4 +2,3 @@ # frozen_string_literal: true require "ansi" -require "unparser" diff --git a/test/rbi/parser_test.rb b/test/rbi/parser_test.rb index 60c0153b..d6ba65c7 100644 --- a/test/rbi/parser_test.rb +++ b/test/rbi/parser_test.rb @@ -800,7 +800,7 @@ def bar; end assert_equal(rbi, out.string) end - def test_parse_trailing_comments_and_moves_them_in_header + def test_parse_collect_dangling_scope_comments rbi = <<~RBI # A comment 1 # A comment 2 @@ -814,25 +814,23 @@ class B; end assert_equal(<<~RBI, out.string) # A comment 1 # A comment 2 - - # A comment 3 module A # B comment class B; end + # A comment 3 end RBI end - def test_parse_comments_and_discard_orphans + def test_parse_collect_dangling_file_comments rbi = <<~RBI module A; end # Orphan comment RBI out = Parser.parse_string(rbi) assert_equal(<<~RBI, out.string) - # Orphan comment - module A; end + # Orphan comment RBI end @@ -871,15 +869,15 @@ def test_parse_errors def bar RBI end - assert_equal("unexpected token $end", e.message) - assert_equal("-:2:0-2:0", e.location.to_s) + assert_equal("Expected to be able to parse an expression. Expected `end` to close `def` statement.", e.message) + assert_equal("-:2:0-1:8", e.location.to_s) e = assert_raises(ParseError) do Parser.parse_string(<<~RBI) private include Foo RBI end - assert_equal("Unexpected token `private` before `send`", e.message) + assert_equal("Unexpected token `private` before `include Foo`", e.message) assert_equal("-:1:0-1:19", e.location.to_s) e = assert_raises(ParseError) do @@ -887,7 +885,7 @@ def bar private class Foo; end RBI end - assert_equal("Unexpected token `private` before `class`", e.message) + assert_equal("Unexpected token `private` before `class Foo; end`", e.message) assert_equal("-:1:0-1:22", e.location.to_s) e = assert_raises(ParseError) do @@ -895,7 +893,7 @@ def bar private CST = 42 RBI end - assert_equal("Unexpected token `private` before `casgn`", e.message) + assert_equal("Unexpected token `private` before `CST = 42`", e.message) assert_equal("-:1:0-1:16", e.location.to_s) end @@ -944,8 +942,8 @@ class Foo e = assert_raises(ParseError) do Parser.parse_file(path) end - assert_equal("unexpected token $end", e.message) - assert_equal("test_parse_real_file_with_error.rbi:2:0-2:0", e.location.to_s) + assert_equal("Expected to be able to parse an expression. Expected `end` to close `class` statement.", e.message) + assert_equal("test_parse_real_file_with_error.rbi:2:0-1:10", e.location.to_s) FileUtils.rm_rf(path) end