@appthreat/atom-parsetools 1.2.2 → 1.4.0

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.9.0/rbi/prism/node_ext.rbi

@@ -1,107 +0,0 @@
-# typed: strict
-
-class Prism::InterpolatedMatchLastLineNode < Prism::Node
-  sig { returns(Integer) }
-  def options; end
-end
-
-class Prism::InterpolatedRegularExpressionNode < Prism::Node
-  sig { returns(Integer) }
-  def options; end
-end
-
-class Prism::MatchLastLineNode < Prism::Node
-  sig { returns(Integer) }
-  def options; end
-end
-
-class Prism::RegularExpressionNode < Prism::Node
-  sig { returns(Integer) }
-  def options; end
-end
-
-class Prism::InterpolatedStringNode < Prism::Node
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-end
-
-class Prism::InterpolatedXStringNode < Prism::Node
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-end
-
-class Prism::StringNode < Prism::Node
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-
-  sig { returns(Prism::InterpolatedStringNode) }
-  def to_interpolated; end
-end
-
-class Prism::XStringNode < Prism::Node
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-
-  sig { returns(Prism::InterpolatedXStringNode) }
-  def to_interpolated; end
-end
-
-class Prism::ImaginaryNode < Prism::Node
-  sig { returns(Complex) }
-  def value; end
-end
-
-class Prism::RationalNode < Prism::Node
-  sig { returns(Rational) }
-  def value; end
-end
-
-class Prism::ConstantReadNode < Prism::Node
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  sig { returns(String) }
-  def full_name; end
-end
-
-class Prism::ConstantWriteNode < Prism::Node
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  sig { returns(String) }
-  def full_name; end
-end
-
-class Prism::ConstantPathNode < Prism::Node
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  sig { returns(String) }
-  def full_name; end
-end
-
-class Prism::ConstantPathTargetNode < Prism::Node
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  sig { returns(String) }
-  def full_name; end
-end
-
-class Prism::ConstantTargetNode < Prism::Node
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  sig { returns(String) }
-  def full_name; end
-end
-
-class Prism::ParametersNode < Prism::Node
-  sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) }
-  def signature; end
-end
-
-class Prism::CallNode < Prism::Node
-  sig { returns(T.nilable(Prism::Location)) }
-  def full_message_loc; end
-end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.9.0/rbi/prism/parse_result.rbi

@@ -1,404 +0,0 @@
-# typed: strict
-
-class Prism::Source
-  sig { returns(String) }
-  def source; end
-
-  sig { returns(Integer) }
-  def start_line; end
-
-  sig { returns(T::Array[Integer]) }
-  def offsets; end
-
-  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
-  def initialize(source, start_line = 1, offsets = []); end
-
-  sig { params(start_line: Integer).void }
-  def replace_start_line(start_line); end
-
-  sig { params(offsets: T::Array[Integer]).void }
-  def replace_offsets(offsets); end
-
-  sig { returns(Encoding) }
-  def encoding; end
-
-  sig { returns(T::Array[String]) }
-  def lines; end
-
-  sig { params(byte_offset: Integer, length: Integer).returns(String) }
-  def slice(byte_offset, length); end
-
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def line(byte_offset); end
-
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def line_start(byte_offset); end
-
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def column(byte_offset); end
-
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_offset(byte_offset); end
-
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_column(byte_offset); end
-
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_offset(byte_offset, encoding); end
-
-  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
-  def code_units_cache(encoding); end
-
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_column(byte_offset, encoding); end
-end
-
-class Prism::CodeUnitsCache
-  sig { params(source: String, encoding: Encoding).void }
-  def initialize(source, encoding); end
-
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def [](byte_offset); end
-end
-
-class Prism::ASCIISource < Prism::Source
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_offset(byte_offset); end
-
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_column(byte_offset); end
-
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_offset(byte_offset, encoding); end
-
-  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
-  def code_units_cache(encoding); end
-
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_column(byte_offset, encoding); end
-end
-
-class Prism::Location
-  sig { returns(Prism::Source) }
-  def source; end
-
-  sig { returns(Integer) }
-  def start_offset; end
-
-  sig { returns(Integer) }
-  def length; end
-
-  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
-  def initialize(source, start_offset, length); end
-
-  sig { returns(T::Array[Prism::Comment]) }
-  def leading_comments; end
-
-  sig { params(comment: Prism::Comment).void }
-  def leading_comment(comment); end
-
-  sig { returns(T::Array[Prism::Comment]) }
-  def trailing_comments; end
-
-  sig { params(comment: Prism::Comment).void }
-  def trailing_comment(comment); end
-
-  sig { returns(T::Array[Prism::Comment]) }
-  def comments; end
-
-  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
-  def copy(source: self.source, start_offset: self.start_offset, length: self.length); end
-
-  sig { returns(Prism::Location) }
-  def chop; end
-
-  sig { returns(String) }
-  def inspect; end
-
-  sig { returns(T::Array[String]) }
-  def source_lines; end
-
-  sig { returns(String) }
-  def slice; end
-
-  sig { returns(Integer) }
-  def start_character_offset; end
-
-  sig { params(encoding: Encoding).returns(Integer) }
-  def start_code_units_offset(encoding = Encoding::UTF_16LE); end
-
-  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
-  def cached_start_code_units_offset(cache); end
-
-  sig { returns(Integer) }
-  def end_offset; end
-
-  sig { returns(Integer) }
-  def end_character_offset; end
-
-  sig { params(encoding: Encoding).returns(Integer) }
-  def end_code_units_offset(encoding = Encoding::UTF_16LE); end
-
-  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
-  def cached_end_code_units_offset(cache); end
-
-  sig { returns(Integer) }
-  def start_line; end
-
-  sig { returns(String) }
-  def start_line_slice; end
-
-  sig { returns(Integer) }
-  def end_line; end
-
-  sig { returns(Integer) }
-  def start_column; end
-
-  sig { returns(Integer) }
-  def start_character_column; end
-
-  sig { params(encoding: Encoding).returns(Integer) }
-  def start_code_units_column(encoding = Encoding::UTF_16LE); end
-
-  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
-  def cached_start_code_units_column(cache); end
-
-  sig { returns(Integer) }
-  def end_column; end
-
-  sig { returns(Integer) }
-  def end_character_column; end
-
-  sig { params(encoding: Encoding).returns(Integer) }
-  def end_code_units_column(encoding = Encoding::UTF_16LE); end
-
-  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
-  def cached_end_code_units_column(cache); end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { params(q: T.untyped).void }
-  def pretty_print(q); end
-
-  sig { params(other: T.untyped).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { params(other: Prism::Location).returns(Prism::Location) }
-  def join(other); end
-
-  sig { params(string: String).returns(Prism::Location) }
-  def adjoin(string); end
-end
-
-class Prism::Comment
-  abstract!
-
-  sig { returns(Prism::Location) }
-  def location; end
-
-  sig { params(location: Prism::Location).void }
-  def initialize(location); end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { returns(String) }
-  def slice; end
-
-  sig { abstract.returns(T::Boolean) }
-  def trailing?; end
-end
-
-class Prism::InlineComment < Prism::Comment
-  sig { override.returns(T::Boolean) }
-  def trailing?; end
-
-  sig { returns(String) }
-  def inspect; end
-end
-
-class Prism::EmbDocComment < Prism::Comment
-  sig { override.returns(T::Boolean) }
-  def trailing?; end
-
-  sig { returns(String) }
-  def inspect; end
-end
-
-class Prism::MagicComment
-  sig { returns(Prism::Location) }
-  def key_loc; end
-
-  sig { returns(Prism::Location) }
-  def value_loc; end
-
-  sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
-  def initialize(key_loc, value_loc); end
-
-  sig { returns(String) }
-  def key; end
-
-  sig { returns(String) }
-  def value; end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { returns(String) }
-  def inspect; end
-end
-
-class Prism::ParseError
-  sig { returns(Symbol) }
-  def type; end
-
-  sig { returns(String) }
-  def message; end
-
-  sig { returns(Prism::Location) }
-  def location; end
-
-  sig { returns(Symbol) }
-  def level; end
-
-  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
-  def initialize(type, message, location, level); end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { returns(String) }
-  def inspect; end
-end
-
-class Prism::ParseWarning
-  sig { returns(Symbol) }
-  def type; end
-
-  sig { returns(String) }
-  def message; end
-
-  sig { returns(Prism::Location) }
-  def location; end
-
-  sig { returns(Symbol) }
-  def level; end
-
-  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
-  def initialize(type, message, location, level); end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { returns(String) }
-  def inspect; end
-end
-
-class Prism::Result
-  sig { params(comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
-  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
-
-  sig { returns(T::Array[Prism::Comment]) }
-  def comments; end
-
-  sig { returns(T::Array[Prism::MagicComment]) }
-  def magic_comments; end
-
-  sig { returns(T.nilable(Prism::Location)) }
-  def data_loc; end
-
-  sig { returns(T::Array[Prism::ParseError]) }
-  def errors; end
-
-  sig { returns(T::Array[Prism::ParseWarning]) }
-  def warnings; end
-
-  sig { returns(Prism::Source) }
-  def source; end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { returns(Encoding) }
-  def encoding; end
-
-  sig { returns(T::Boolean) }
-  def success?; end
-
-  sig { returns(T::Boolean) }
-  def failure?; end
-
-  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
-  def code_units_cache(encoding); end
-end
-
-class Prism::ParseResult < Prism::Result
-  sig { params(value: Prism::ProgramNode, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
-
-  sig { returns(Prism::ProgramNode) }
-  def value; end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-end
-
-class Prism::LexResult < Prism::Result
-  sig { params(value: T::Array[T.untyped], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
-
-  sig { returns(T::Array[T.untyped]) }
-  def value; end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-end
-
-class Prism::ParseLexResult < Prism::Result
-  sig { params(value: [Prism::ProgramNode, T::Array[T.untyped]], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
-
-  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
-  def value; end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-end
-
-class Prism::Token
-  sig { returns(Prism::Source) }
-  def source; end
-
-  sig { returns(Symbol) }
-  def type; end
-
-  sig { returns(String) }
-  def value; end
-
-  sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
-  def initialize(source, type, value, location); end
-
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { returns(Prism::Location) }
-  def location; end
-
-  sig { params(q: T.untyped).void }
-  def pretty_print(q); end
-
-  sig { params(other: T.untyped).returns(T::Boolean) }
-  def ==(other); end
-end
-
-class Prism::Scope
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  sig { returns(T::Array[Symbol]) }
-  def forwarding; end
-
-  sig { params(locals: T::Array[Symbol], forwarding: T::Array[Symbol]).void }
-  def initialize(locals, forwarding); end
-end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.9.0/rbi/prism/reflection.rbi

@@ -1,58 +0,0 @@
-# typed: strict
-
-module Prism::Reflection
-end
-
-class Prism::Reflection::Field
-  sig { params(name: Symbol).void }
-  def initialize(name); end
-
-  sig { returns(Symbol) }
-  def name; end
-end
-
-class Prism::Reflection::NodeField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::OptionalNodeField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::NodeListField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::ConstantField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::OptionalConstantField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::ConstantListField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::StringField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::LocationField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::OptionalLocationField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::IntegerField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::FloatField < Prism::Reflection::Field
-end
-
-class Prism::Reflection::FlagsField < Prism::Reflection::Field
-  sig { params(name: Symbol, flags: T::Array[Symbol]).void }
-  def initialize(name, flags); end
-
-  sig { returns(T::Array[Symbol]) }
-  def flags; end
-end
-
-module Prism::Reflection
-  sig { params(node: T.class_of(Prism::Node)).returns(T::Array[Prism::Reflection::Field]) }
-  def self.fields_for(node); end
-end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.9.0/rbi/prism/string_query.rbi

@@ -1,12 +0,0 @@
-# typed: strict
-
-class Prism::StringQuery
-  sig { params(string: String).returns(T::Boolean) }
-  def self.local?(string); end
-
-  sig { params(string: String).returns(T::Boolean) }
-  def self.constant?(string); end
-
-  sig { params(string: String).returns(T::Boolean) }
-  def self.method_name?(string); end
-end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.9.0/rbi/prism/translation/parser.rbi

@@ -1,11 +0,0 @@
-# typed: strict
-
-# We keep these shims in here because our client libraries might not have parser
-# in their bundle.
-module Parser; end
-class Parser::Base; end
-
-class Prism::Translation::Parser < Parser::Base
-  sig { overridable.returns(Integer) }
-  def version; end
-end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.9.0/rbi/prism/translation/parser_versions.rbi

@@ -1,23 +0,0 @@
-# typed: strict
-
-class Prism::Translation::Parser33 < Prism::Translation::Parser
-  sig { override.returns(Integer) }
-  def version; end
-end
-
-class Prism::Translation::Parser34 < Prism::Translation::Parser
-  sig { override.returns(Integer) }
-  def version; end
-end
-
-class Prism::Translation::Parser40 < Prism::Translation::Parser
-  sig { override.returns(Integer) }
-  def version; end
-end
-
-Prism::Translation::Parser35 = Prism::Translation::Parser40
-
-class Prism::Translation::Parser40 < Prism::Translation::Parser
-  sig { override.returns(Integer) }
-  def version; end
-end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.9.0/rbi/prism/translation/ripper.rbi

@@ -1,15 +0,0 @@
-# typed: strict
-
-class Prism::Translation::Ripper < Prism::Compiler
-  sig { returns(T::Boolean) }
-  def error?; end
-
-  sig { returns(T.untyped) }
-  def parse; end
-
-  sig { params(source: String, filename: String, lineno: Integer, raise_errors: T.untyped).returns(T.untyped) }
-  def self.sexp_raw(source, filename = "-", lineno = 1, raise_errors: false); end
-
-  sig { params(source: String, filename: String, lineno: Integer, raise_errors: T.untyped).returns(T.untyped) }
-  def self.sexp(source, filename = "-", lineno = 1, raise_errors: false); end
-end