jruby-prism-parser 0.24.0-java → 1.4.0-java

data/rbi/prism_static.rbi

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

data/sig/prism_static.rbs

@@ -1,201 +0,0 @@
-module Prism
-  BACKEND: :CEXT | :FFI
-  VERSION: String
-
-  def self.parse: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> ParseResult[ProgramNode]
-  def self.lex: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> ParseResult[Array[[Token, Integer]]]
-  def self.parse_lex: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> ParseResult[[ProgramNode, Array[[Token, Integer]]]]
-  def self.dump: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> String
-  def self.parse_comments: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> Array[Comment]
-  def self.parse_success?: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> bool
-  def self.parse_failure?: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> bool
-
-  def self.parse_file: (String filepath, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> ParseResult[ProgramNode]
-  def self.lex_file: (String filepath, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> ParseResult[Array[[Token, Integer]]]
-  def self.parse_lex_file: (String filepath, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> ParseResult[[ProgramNode, Array[[Token, Integer]]]]
-  def self.dump_file: (String filepath, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> String
-  def self.parse_file_comments: (String filepath, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> Array[Comment]
-  def self.parse_file_failure?: (String filepath, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> bool
-  def self.parse_file_success?: (String filepath, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> bool
-
-  def self.load: (String source, String serialized) -> ParseResult[ProgramNode]
-
-  type ripper_token = [[Integer, Integer], Symbol, String, untyped]
-  def self.lex_compat: (String source, ?filepath: String, ?line: Integer, ?encoding: Encoding, ?frozen_string_literal: bool, ?scopes: Array[Array[Symbol]]) -> ParseResult[Array[ripper_token]]
-  def self.lex_ripper: (String source) -> Array[ripper_token]
-
-  class ParseResult[T]
-    attr_reader value: T
-    attr_reader comments: Array[Comment]
-    attr_reader magic_comments: Array[MagicComment]
-    attr_reader data_loc: Location?
-    attr_reader errors: Array[ParseError]
-    attr_reader warnings: Array[ParseWarning]
-    attr_reader source: Source
-
-    def initialize: (T value, Array[Comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { value: T, comments: Array[Comment], magic_comments: Array[MagicComment], data_loc: Location?, errors: Array[ParseError], warnings: Array[ParseWarning] }
-    def success?: () -> bool
-    def failure?: () -> bool
-  end
-
-  class ParseError
-    attr_reader message: String
-    attr_reader location: Location
-
-    def initialize: (String message, Location location) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { message: String, location: Location }
-  end
-
-  class ParseWarning
-    attr_reader message: String
-    attr_reader location: Location
-
-    def initialize: (String message, Location location) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { message: String, location: Location }
-  end
-
-  class Node
-    @newline: bool
-
-    attr_reader location: Location
-
-    def child_nodes: () -> Array[Node?]
-    def newline?: () -> bool
-    def set_newline_flag: (Array[bool] newline_marked) -> void
-    def slice: () -> String
-    def pretty_print: (untyped q) -> untyped
-    def inspect: (?NodeInspector inspector) -> String  # TODO: not right, only is defined on subclasses
-    def to_dot: () -> String
-  end
-
-  class Comment
-    attr_reader location: Location
-
-    def initialize: (Location location) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  end
-
-  class InlineComment < Comment
-    def trailing?: () -> bool
-  end
-
-  class EmbDocComment < Comment
-    def trailing?: () -> false
-  end
-
-  class MagicComment
-    attr_reader key_loc: Location
-    attr_reader value_loc: Location
-
-    def initialize: (Location key_loc, Location value_loc) -> void
-
-    def key: () -> String
-    def value: () -> String
-
-    def deconstruct_keys: (Array[Symbol] keys) -> { key_loc: Location, value_loc: Location }
-  end
-
-  class Location
-    attr_reader source: Source | nil
-    attr_reader start_offset: Integer
-    attr_reader length: Integer
-    attr_reader comments: Array[Comment]
-
-    def initialize: (Source? source, Integer start_offset, Integer length) -> void
-    def copy: (?source: Source, ?start_offset: Integer, ?length: Integer) -> Location
-    def slice: () -> String
-    def start_character_offset: () -> Integer
-    def end_offset: () -> Integer
-    def end_character_offset: () -> Integer
-    def start_line: () -> Integer
-    def start_line_slice: () -> String
-    def end_line: () -> Integer
-    def start_column: () -> Integer
-    def start_character_column: () -> Integer
-    def end_column: () -> Integer
-    def end_character_column: () -> Integer
-    def deconstruct_keys: (Array[Symbol] keys) -> { start_offset: Integer, end_offset: Integer }
-    def pretty_print: (untyped q) -> untyped
-    def join: (Location other) -> Location
-
-    def self.null: () -> Location
-  end
-
-  class Source
-    attr_reader source: String
-    attr_reader start_line: Integer
-    attr_reader offsets: Array[Integer]
-
-    def initialize: (String source, ?Integer start_line, ?Array[Integer] offsets) -> void
-    def slice: (Integer byte_offset, Integer length) -> String
-    def line: (Integer byte_offset) -> Integer
-    def line_offset: (Integer byte_offset) -> Integer
-    def column: (Integer byte_offset) -> Integer
-    def character_offset: (Integer byte_offset) -> Integer
-    def character_column: (Integer byte_offset) -> Integer
-  end
-
-  class Token
-    attr_reader type: Symbol
-    attr_reader value: String
-    attr_reader location: Location
-
-    def initialize: (Symbol type, String value, Location location) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { type: Symbol, value: String, location: Location }
-    def pretty_print: (untyped q) -> untyped
-    def ==: (untyped other) -> bool
-  end
-
-  class NodeInspector
-    attr_reader prefix: String
-    attr_reader output: String
-
-    @prefix: String
-    @output: String
-
-    def initialize: (?String prefix) -> void
-
-    # Appends a line to the output with the current prefix.
-    def <<: (String line) -> void
-
-    # This generates a string that is used as the header of the inspect output
-    # for any given node.
-    def header: (Node node) -> String
-
-    # Generates a string that represents a list of nodes. It handles properly
-    # using the box drawing characters to make the output look nice.
-    def list: (String prefix, Array[Node] nodes) -> String
-
-    # Generates a string that represents a location field on a node.
-    def location: (Location? value) -> String
-
-    # Generates a string that represents a child node.
-    def child_node: (Node node, String append) -> String
-
-    # Returns a new inspector that can be used to inspect a child node.
-    def child_inspector: (String append) -> NodeInspector
-
-    # Returns the output as a string.
-    def to_str: () -> String
-  end
-
-  class BasicVisitor
-    def visit: (Node? node) -> void
-    def visit_all: (Array[Node?] nodes) -> void
-    def visit_child_nodes: (Node node) -> void
-  end
-
-  class Pattern
-    class CompilationError < StandardError
-    end
-
-    attr_reader query: String
-
-    @compiled: Proc
-
-    def initialize: (String query) -> void
-    def compile: () -> Proc
-    def scan: (Node root) -> void
-  end
-end

data/src/util/pm_state_stack.c

@@ -1,25 +0,0 @@
-#include "prism/util/pm_state_stack.h"
-
-/**
- * Pushes a value onto the stack.
- */
-void
-pm_state_stack_push(pm_state_stack_t *stack, bool value) {
-    *stack = (*stack << 1) | (value & 1);
-}
-
-/**
- * Pops a value off the stack.
- */
-void
-pm_state_stack_pop(pm_state_stack_t *stack) {
-    *stack >>= 1;
-}
-
-/**
- * Returns the value at the top of the stack.
- */
-bool
-pm_state_stack_p(pm_state_stack_t *stack) {
-    return *stack & 1;
-}

data/src/util/pm_string_list.c

@@ -1,28 +0,0 @@
-#include "prism/util/pm_string_list.h"
-
-/**
- * Append a pm_string_t to the given string list.
- */
-void
-pm_string_list_append(pm_string_list_t *string_list, pm_string_t *string) {
-    if (string_list->length + 1 > string_list->capacity) {
-        if (string_list->capacity == 0) {
-            string_list->capacity = 1;
-        } else {
-            string_list->capacity *= 2;
-        }
-
-        string_list->strings = realloc(string_list->strings, string_list->capacity * sizeof(pm_string_t));
-        if (string_list->strings == NULL) abort();
-    }
-
-    string_list->strings[string_list->length++] = *string;
-}
-
-/**
- * Free the memory associated with the string list
- */
-void
-pm_string_list_free(pm_string_list_t *string_list) {
-    free(string_list->strings);
-}