herb 0.7.2-x86-linux-gnu → 0.7.4-x86-linux-gnu

data/vendor/prism/templates/rbi/prism/dsl.rbi.erb

@@ -0,0 +1,68 @@
+module Prism::DSL
+  sig { params(string: String).returns(Prism::Source) }
+  def source(string); end
+
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
+  def location(source: default_source, start_offset: 0, length: 0); end
+  <%- nodes.each do |node| -%>
+  <%-
+  params = [
+    ["source", "default_source", "Prism::Source"],
+    ["node_id", "0", "Integer"],
+    ["location", "default_location", "Prism::Location"],
+    ["flags", "0", "Integer"]
+  ].concat(node.fields.map { |field|
+    case field
+    when Prism::Template::NodeField
+      kind = field.specific_kind || field.union_kind&.first
+      if kind.nil?
+        [field.name, "default_node(source, location)", field.rbi_class]
+      else
+        [field.name, %Q{#{kind.gsub(/(?<=.)[A-Z]/, "_\\0").downcase}(source: source)}, field.rbi_class]
+      end
+    when Prism::Template::OptionalNodeField
+      [field.name, "nil", field.rbi_class]
+    when Prism::Template::NodeListField
+      [field.name, "[]", field.rbi_class]
+    when Prism::Template::ConstantField
+      [field.name, ":\"\"", field.rbi_class]
+    when Prism::Template::OptionalConstantField
+      [field.name, "nil", field.rbi_class]
+    when Prism::Template::ConstantListField
+      [field.name, "[]", field.rbi_class]
+    when Prism::Template::StringField
+      [field.name, "\"\"", field.rbi_class]
+    when Prism::Template::LocationField
+      [field.name, "location", field.rbi_class]
+    when Prism::Template::OptionalLocationField
+      [field.name, "nil", field.rbi_class]
+    when Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::IntegerField
+      [field.name, "0", field.rbi_class]
+    when Prism::Template::DoubleField
+      [field.name, "0.0", field.rbi_class]
+    else
+      raise
+    end
+  })
+  -%>
+
+  sig { params(<%= params.map { |(name, _, type)| "#{name}: #{type}" }.join(", ") %>).returns(Prism::<%= node.name %>) }
+  def <%= node.human %>(<%= params.map { |(name, default, _)| "#{name}: #{default}" }.join(", ") %>); end
+  <%- end -%>
+  <%- flags.each do |flag| -%>
+
+  sig { params(name: Symbol).returns(Integer) }
+  def <%= flag.human.chomp("s") %>(name); end
+  <%- end -%>
+
+  private
+
+  sig { returns(Prism::Source) }
+  def default_source; end
+
+  sig { returns(Prism::Location) }
+  def default_location; end
+
+  sig { params(source: Prism::Source, location: Prism::Location).returns(Prism::Node) }
+  def default_node(source, location); end
+end

data/vendor/prism/templates/rbi/prism/node.rbi.erb

@@ -0,0 +1,164 @@
+class Prism::Node
+  abstract!
+
+  sig { returns(Prism::Source) }
+  def source; end
+
+  sig { returns(Integer) }
+  def node_id; end
+
+  sig { returns(Prism::Location) }
+  def location; end
+
+  sig{ returns(Integer) }
+  def flags; end
+
+  sig { returns(T::Boolean) }
+  def newline?; end
+
+  sig { returns(T::Boolean) }
+  def static_literal?; end
+
+  sig { returns(Integer) }
+  def start_offset; end
+
+  sig { returns(Integer) }
+  def end_offset; end
+
+  sig { returns(T::Array[String]) }
+  def source_lines; end
+
+  sig { returns(T::Array[String]) }
+  def script_lines; end
+
+  sig { returns(String) }
+  def slice; end
+
+  sig { returns(String) }
+  def slice_lines; end
+
+  sig { params(q: T.untyped).void }
+  def pretty_print(q); end
+
+  sig { returns(String) }
+  def to_dot; end
+
+  sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) }
+  def tunnel(line, column); end
+
+  sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) }
+  def breadth_first_search(&block); end
+
+  sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { abstract.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  sig { abstract.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  sig { abstract.returns(Symbol) }
+  def type; end
+
+  sig { abstract.returns(String) }
+  def inspect; end
+end
+<%- nodes.each do |node| -%>
+
+<%- node.each_comment_line do |line| -%>
+#<%= line %>
+<%- end -%>
+class Prism::<%= node.name -%> < Prism::Node
+  <%- if (node_flags = node.flags) -%>
+  <%- node_flags.values.each do |value| -%>
+  sig { returns(T::Boolean) }
+  def <%= value.name.downcase %>?; end
+
+  <%- end -%>
+  <%- end -%>
+  <%- node.fields.each do |field| -%>
+  sig { returns(<%= field.rbi_class %>) }
+  def <%= field.name %>; end
+
+  <%- end -%>
+  sig { params(<%= ["source: Prism::Source", "node_id: Integer", "location: Prism::Location", "flags: Integer", *node.fields.map { |field| "#{field.name}: #{field.rbi_class}" }].join(", ") %>).void }
+  def initialize(<%= ["source", "node_id", "location", "flags", *node.fields.map(&:name)].join(", ") %>); end
+
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  sig { params(<%= (["node_id: Integer", "location: Prism::Location", "flags: Integer"] + node.fields.map { |field| "#{field.name}: #{field.rbi_class}" }).join(", ") %>).returns(Prism::<%= node.name %>) }
+  def copy(<%= (["node_id", "location", "flags"] + node.fields.map(&:name)).map { |field| "#{field}: self.#{field}" }.join(", ") %>); end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Prism::Template::LocationField -%>
+  <%- raise unless field.name.end_with?("_loc") -%>
+  <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>
+
+  sig { returns(String) }
+  def <%= field.name.delete_suffix("_loc") %>; end
+  <%- when Prism::Template::OptionalLocationField -%>
+  <%- raise unless field.name.end_with?("_loc") -%>
+  <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>
+
+  sig { returns(T.nilable(String)) }
+  def <%= field.name.delete_suffix("_loc") %>; end
+  <%- end -%>
+  <%- end -%>
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  sig { override.returns(String) }
+  def inspect; end
+
+  sig { override.returns(Symbol) }
+  def type; end
+end
+<%- end -%>
+<%- flags.each do |flag| -%>
+
+# <%= flag.comment %>
+module Prism::<%= flag.name %>
+  <%- flag.values.each_with_index do |value, index| -%>
+  # <%= value.comment %>
+  <%= value.name %> = T.let(1 << <%= index + Prism::Template::COMMON_FLAGS_COUNT %>, Integer)
+  <%- end -%>
+end
+<%- end -%>
+
+# The flags that are common to all nodes.
+module Prism::NodeFlags
+  # A flag to indicate that the node is a candidate to emit a :line event
+  # through tracepoint when compiled.
+  NEWLINE = T.let(1, Integer)
+
+  # A flag to indicate that the value that the node represents is a value that
+  # can be determined at parse-time.
+  STATIC_LITERAL = T.let(2, Integer)
+end

data/vendor/prism/templates/rbi/prism/visitor.rbi.erb

@@ -0,0 +1,18 @@
+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
+
+class Prism::Visitor < Prism::BasicVisitor
+  <%- nodes.each_with_index do |node, index| -%>
+<%= "\n" if index != 0 -%>
+  sig { params(node: Prism::<%= node.name %>).void }
+  def visit_<%= node.human %>(node); end
+  <%- end -%>
+end

data/vendor/prism/templates/sig/prism/_private/dot_visitor.rbs.erb

@@ -0,0 +1,45 @@
+module Prism
+  class DotVisitor < Visitor
+    class Field
+      attr_reader name: String
+      attr_reader value: String?
+      attr_reader port: bool
+
+      def initialize: (String name, String? value, bool port) -> void
+      def to_dot: () -> String
+    end
+
+    class Table
+      attr_reader name: String
+      attr_reader fields: Array[Field]
+
+      def initialize: (String name) -> void
+      def field: (String name, ?String? value, ?port: bool) -> void
+      def to_dot: () -> String
+    end
+
+    class Digraph
+      attr_reader nodes: Array[String]
+      attr_reader waypoints: Array[String]
+      attr_reader edges: Array[String]
+
+      def initialize: () -> void
+      def node: (String value) -> void
+      def waypoint: (String value) -> void
+      def edge: (String value) -> void
+
+      def to_dot: () -> String
+    end
+
+    attr_reader digraph: Digraph
+
+    private
+
+    def node_id: (Prism::node node) -> String
+    def location_inspect: (Location location) -> String
+
+    <%- flags.each do |flag| -%>
+    def <%= flag.human %>_inspect: (<%= nodes.filter_map { |node| node.name if node.flags == flag }.join(" | ") %> node) -> String
+    <%- end -%>
+  end
+end

data/vendor/prism/templates/sig/prism/dsl.rbs.erb

@@ -0,0 +1,31 @@
+module Prism
+  module DSL
+    def source: (String string) -> Source
+
+    def location: (?source: Source, ?start_offset: Integer, ?length: Integer) -> Location
+    <%- nodes.each do |node| -%>
+    <%-
+    params = [
+      ["source", "Source"],
+      ["node_id", "Integer"],
+      ["location", "Location"],
+      ["flags", "Integer"]
+    ].concat(node.fields.map { |field| [field.name, field.rbs_class] })
+    -%>
+
+    def <%= node.human %>: (<%= params.map { |(name, type)| "?#{name}: #{type}" }.join(", ") %>) -> <%= node.name %>
+    <%- end -%>
+    <%- flags.each do |flag| -%>
+
+    def <%= flag.human.chomp("s") %>: (Symbol name) -> Integer
+    <%- end -%>
+
+    private
+
+    def default_source: () -> Source
+
+    def default_location: () -> Location
+
+    def default_node: (Source source, Location location) -> node
+  end
+end

data/vendor/prism/templates/sig/prism/mutation_compiler.rbs.erb

@@ -0,0 +1,7 @@
+module Prism
+  class MutationCompiler < Compiler
+    <%- nodes.each do |node| -%>
+    def visit_<%= node.human %>: (<%= node.name %>) -> node?
+    <%- end -%>
+  end
+end

data/vendor/prism/templates/sig/prism/node.rbs.erb

@@ -0,0 +1,132 @@
+module Prism
+  class Node
+    attr_reader source: Source
+    attr_reader node_id: Integer
+    attr_reader location: Location
+    attr_reader flags: Integer
+
+    def newline?: () -> bool
+    def static_literal?: () -> bool
+
+    def accept: (_Visitor) -> void
+    def child_nodes: () -> Array[Prism::node?]
+    def comment_targets: () -> Array[Prism::node | Location]
+    def compact_child_nodes: () -> Array[Prism::node]
+    def self.fields: () -> Array[Prism::Reflection::Field]
+    def type: () -> Symbol
+    def self.type: () -> Symbol
+
+    def source_lines: () -> Array[String]
+    alias script_lines source_lines
+    def slice: () -> String
+    def slice_lines: () -> String
+    def pretty_print: (untyped q) -> untyped
+    def to_dot: () -> String
+    def tunnel: (Integer line, Integer column) -> Array[Prism::node]
+    def breadth_first_search: () { (Prism::node) -> bool } -> Prism::node?
+    def newline!: (Array[untyped]) -> void
+
+    def save: (_Repository repository) -> void
+    def save_location: (_Repository repository) -> void
+
+    def leading_comments: () -> Array[comment]
+    def trailing_comments: () -> Array[comment]
+    def comments: () -> Array[comment]
+
+    def start_offset: () -> Integer
+    def start_character_offset: () -> Integer
+    def start_code_units_offset: (Encoding encoding) -> Integer
+    def cached_start_code_units_offset: (_CodeUnitsCache cache) -> Integer
+
+    def end_offset: () -> Integer
+    def end_character_offset: () -> Integer
+    def end_code_units_offset: (Encoding encoding) -> Integer
+    def cached_end_code_units_offset: (_CodeUnitsCache cache) -> Integer
+
+    def start_line: () -> Integer
+    def end_line: () -> Integer
+
+    def start_column: () -> Integer
+    def start_character_column: () -> Integer
+    def start_code_units_column: (Encoding encoding) -> Integer
+    def cached_start_code_units_column: (_CodeUnitsCache cache) -> Integer
+
+    def end_column: () -> Integer
+    def end_character_column: () -> Integer
+    def end_code_units_column: (Encoding encoding) -> Integer
+    def cached_end_code_units_column: (_CodeUnitsCache cache) -> Integer
+  end
+
+  # Methods implemented by every subclass of Node
+  interface _Node
+    def deconstruct: () -> Array[Prism::node?]
+    def inspect: () -> String
+  end
+
+  type node = Node & _Node
+
+  interface _Repository
+    def enter: (Integer node_id, Symbol field_name) -> void
+  end
+
+  <%- nodes.each do |node| -%>
+
+  <%- node.each_comment_line do |line| -%>
+  #<%= line %>
+  <%- end -%>
+  class <%= node.name -%> < Node
+    include _Node
+    <%- if (node_flags = node.flags) -%>
+
+    <%- node_flags.values.each do |value| -%>
+    def <%= value.name.downcase %>?: () -> bool
+    <%- end -%>
+    <%- end -%>
+
+    <%- node.fields.each do |field| -%>
+    attr_reader <%= field.name %>: <%= field.rbs_class %>
+    <%- end -%>
+    <%- if (locations = node.fields.select { |field| field.is_a?(Prism::Template::LocationField) || field.is_a?(Prism::Template::OptionalLocationField) }) -%>
+
+    <%- locations.each do |field| -%>
+    def save_<%= field.name %>: (_Repository repository) -> void
+    <%- end -%>
+    <%- end -%>
+
+    def initialize: (<%= ["Source source", "Integer node_id", "Location location", "Integer flags", *node.fields.map { |field| "#{field.rbs_class} #{field.name}" }].join(", ") %>) -> void
+    def copy: (<%= (["?node_id: Integer", "?location: Location", "?flags: Integer"] + node.fields.map { |field| "?#{field.name}: #{field.rbs_class}" }).join(", ") %>) -> <%= node.name %>
+    def deconstruct_keys: (Array[Symbol] keys) -> { <%= (["node_id: Integer", "location: Location"] + node.fields.map { |field| "#{field.name}: #{field.rbs_class}" }).join(", ") %> }
+    <%- node.fields.each do |field| -%>
+    <%- case field -%>
+    <%- when Prism::Template::LocationField -%>
+    <%- raise unless field.name.end_with?("_loc") -%>
+    <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>
+    def <%= field.name.delete_suffix("_loc") %>: () -> String
+    <%- when Prism::Template::OptionalLocationField -%>
+    <%- raise unless field.name.end_with?("_loc") -%>
+    <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>
+    def <%= field.name.delete_suffix("_loc") %>: () -> String?
+    <%- end -%>
+    <%- end -%>
+    def type: () -> :<%= node.human %>
+            | ...
+    def self.type: () -> :<%= node.human %>
+  end
+  <%- end -%>
+  <%- flags.each do |flag| -%>
+
+  # <%= flag.comment %>
+  module <%= flag.name %>
+    <%- flag.values.each do |value| -%>
+    # <%= value.comment %>
+    <%= value.name %>: Integer
+    <%- end -%>
+  end
+  <%- end -%>
+
+  # The flags that are common to all nodes.
+  module NodeFlags
+    NEWLINE: Integer
+    STATIC_LITERAL: Integer
+  end
+end

data/vendor/prism/templates/sig/prism/visitor.rbs.erb

@@ -0,0 +1,17 @@
+module Prism
+  class BasicVisitor
+    def visit: (Prism::node?) -> void
+    def visit_all: (Array[Prism::node?]) -> void
+    def visit_child_nodes: (Prism::node) -> void
+  end
+
+  interface _Visitor
+    <%- nodes.each do |node| -%>
+    def visit_<%= node.human %>: (<%= node.name %>) -> void
+    <%- end -%>
+  end
+
+  class Visitor < BasicVisitor
+    include _Visitor
+  end
+end

data/vendor/prism/templates/sig/prism.rbs.erb

@@ -0,0 +1,89 @@
+module Prism
+  BACKEND: :CEXT | :FFI
+  VERSION: String
+
+  # Methods taking a Ruby source code string:
+  <%-
+    {
+      parse: "ParseResult",
+      profile: "nil",
+      lex: "LexResult",
+      lex_compat: "LexCompat::Result",
+      parse_lex: "ParseLexResult",
+      dump: "String",
+      parse_comments: "Array[comment]",
+      parse_success?: "bool",
+      parse_failure?: "bool",
+    }.each do |method, return_type|
+  -%>
+
+  def self.<%= method %>: (
+    String source,
+    ?encoding: Encoding | false,
+    ?filepath: String,
+    ?freeze: bool,
+    ?frozen_string_literal: bool,
+    ?line: Integer,
+    ?main_script: bool,
+    ?offset: Integer,
+    ?scopes: Array[Array[Symbol]],
+    ?verbose: bool
+  ) -> <%= return_type %>
+  <%- end -%>
+
+  def self.load: (
+    String source,
+    String serialized,
+    ?bool freeze
+  ) -> ParseResult
+
+  def self.lex_ripper: (
+    String source
+  ) -> Array[[[Integer, Integer], Symbol, String, untyped]]
+
+  # Methods taking a path to a Ruby file:
+  <%-
+    {
+      parse_file: "ParseResult",
+      profile_file: "nil",
+      lex_file: "LexResult",
+      parse_lex_file: "ParseLexResult",
+      dump_file: "String",
+      parse_file_comments: "Array[comment]",
+      parse_file_success?: "bool",
+      parse_file_failure?: "bool",
+    }.each do |method, return_type|
+  -%>
+
+  def self.<%= method %>: (
+    String filepath,
+    ?encoding: Encoding | false,
+    ?freeze: bool,
+    ?frozen_string_literal: bool,
+    ?line: Integer,
+    ?main_script: bool,
+    ?offset: Integer,
+    ?scopes: Array[Array[Symbol]],
+    ?verbose: bool
+  ) -> <%= return_type %>
+  <%- end -%>
+
+  interface _Stream
+    def gets: (?Integer integer) -> (String | nil)
+  end
+
+  def self.parse_stream: (
+    _Stream stream,
+    ?encoding: Encoding | false,
+    ?filepath: String,
+    ?freeze: bool,
+    ?frozen_string_literal: bool,
+    ?line: Integer,
+    ?main_script: bool,
+    ?offset: Integer,
+    ?scopes: Array[Array[Symbol]],
+    ?verbose: bool
+  ) -> ParseResult
+
+  def self.scope: (?locals: Array[Symbol], ?forwarding: Array[Symbol]) -> Scope
+end