@appthreat/atom-parsetools 1.0.4 → 1.0.5

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.4.0/rbi/prism/node_ext.rbi

@@ -0,0 +1,107 @@
+# 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/3.4.0/gems/prism-1.4.0/rbi/prism/parse_result.rbi

@@ -0,0 +1,404 @@
+# 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/3.4.0/gems/prism-1.4.0/rbi/prism/reflection.rbi

@@ -0,0 +1,58 @@
+# 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/3.4.0/gems/prism-1.4.0/rbi/prism/string_query.rbi

@@ -0,0 +1,12 @@
+# 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/3.4.0/gems/prism-1.4.0/rbi/prism/translation/parser.rbi

@@ -0,0 +1,11 @@
+# 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/3.4.0/gems/prism-1.4.0/rbi/prism/translation/parser33.rbi

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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.4.0/rbi/prism/translation/parser34.rbi

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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.4.0/rbi/prism/translation/parser35.rbi

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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.4.0/rbi/prism/translation/ripper.rbi

@@ -0,0 +1,15 @@
+# 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