jruby-prism-parser 0.23.0.pre.SNAPSHOT-java

data/rbi/prism_static.rbi

@@ -0,0 +1,207 @@
+class Prism::ParseResult
+  sig { returns(Prism::ProgramNode) }
+  def value; end
+
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; 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
+end
+
+class Prism::ParseError
+  sig { returns(String) }
+  def message; end
+
+  sig { returns(Prism::Location) }
+  def location; end
+end
+
+class Prism::ParseWarning
+  sig { returns(String) }
+  def message; end
+
+  sig { returns(Prism::Location) }
+  def location; end
+end
+
+class Prism::Node
+  sig { returns(Prism::Location) }
+  def location; end
+
+  sig { returns(String) }
+  def slice; end
+
+  sig { returns(String) }
+  def to_dot; end
+
+  sig { params(visitor: Prism::Visitor).void }
+  def accept(visitor); end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { returns(Symbol) }
+  def type; end
+end
+
+class Prism::Comment
+  sig { returns(Prism::Location) }
+  def location; end
+
+  sig { returns(T::Boolean) }
+  def trailing?; end
+end
+
+class Prism::InlineComment < Prism::Comment
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
+
+class Prism::EmbDocComment < Prism::Comment
+end
+
+class Prism::DATAComment < Prism::Comment
+end
+
+class Prism::Location
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
+  def initialize(source, start_offset, length); end
+
+  sig { returns(String) }
+  def slice; end
+
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
+
+  sig { params(options: T.untyped).returns(Prism::Location) }
+  def copy(**options); end
+
+  sig { returns(Integer) }
+  def start_offset; end
+
+  sig { returns(Integer) }
+  def end_offset; end
+
+  sig { returns(Integer) }
+  def start_line; end
+
+  sig { returns(Integer) }
+  def end_line; end
+
+  sig { returns(Integer) }
+  def start_column; end
+
+  sig { returns(Integer) }
+  def end_column; end
+end
+
+class Prism::Source
+  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
+  def initialize(source, start_line, offsets); end
+
+  sig { params(offset: Integer, length: Integer).returns(String) }
+  def slice(offset, length); end
+
+  sig { params(value: Integer).returns(Integer) }
+  def line(value); end
+
+  sig { params(value: Integer).returns(Integer) }
+  def line_offset(value); end
+
+  sig { params(value: Integer).returns(Integer) }
+  def column(value); end
+
+  sig { returns(String) }
+  def source; end
+
+  sig { returns(T::Array[Integer]) }
+  def offsets; end
+end
+
+class Prism::Token
+  sig { params(type: T.untyped, value: String, location: Prism::Location).void }
+  def initialize(type, value, location); end
+
+  sig { params(keys: T.untyped).returns(T.untyped) }
+  def deconstruct_keys(keys); end
+
+  sig { params(q: T.untyped).returns(T.untyped) }
+  def pretty_print(q); end
+
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T.untyped) }
+  def type; end
+
+  sig { returns(String) }
+  def value; end
+
+  sig { returns(Prism::Location) }
+  def location; end
+end
+
+class Prism::NodeInspector
+  sig { params(prefix: String).void }
+  def initialize(prefix); end
+
+  sig { returns(String) }
+  def prefix; end
+
+  sig { returns(String) }
+  def output; end
+
+  # Appends a line to the output with the current prefix.
+  sig { params(line: String).void }
+  def <<(line); end
+
+  # This generates a string that is used as the header of the inspect output
+  # for any given node.
+  sig { params(node: Prism::Node).returns(String) }
+  def header(node); end
+
+  # Generates a string that represents a list of nodes. It handles properly
+  # using the box drawing characters to make the output look nice.
+  sig { params(prefix: String, nodes: T::Array[Prism::Node]).returns(String) }
+  def list(prefix, nodes); end
+
+  # Generates a string that represents a location field on a node.
+  sig { params(value: Prism::Location).returns(String) }
+  def location(value); end
+
+  # Generates a string that represents a child node.
+  sig { params(node: Prism::Node, append: String).returns(String) }
+  def child_node(node, append); end
+
+  # Returns a new inspector that can be used to inspect a child node.
+  sig { params(append: String).returns(Prism::NodeInspector) }
+  def child_inspector(append); end
+
+  # Returns the output as a string.
+  sig { returns(String) }
+  def to_str; end
+end
+
+class Prism::BasicVisitor
+  sig { params(node: T.nilable(Prism::Node)).void }
+  def visit(node); end
+
+  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
+  def visit_all(nodes); end
+
+  sig { params(node: Prism::Node).void }
+  def visit_child_nodes(node); end
+end